bitbadgesjs-sdk 0.3.94 → 0.3.95

package/dist/esm/proto/tendermint/abci/types_pb.js

@@ -0,0 +1,1376 @@
+import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
+import { ConsensusParams } from "../types/params_pb.js";
+import { Header } from "../types/types_pb.js";
+import { ProofOps } from "../crypto/proof_pb.js";
+import { PublicKey } from "../crypto/keys_pb.js";
+export var CheckTxType;
+(function (CheckTxType) {
+    CheckTxType[CheckTxType["NEW"] = 0] = "NEW";
+    CheckTxType[CheckTxType["RECHECK"] = 1] = "RECHECK";
+})(CheckTxType || (CheckTxType = {}));
+proto3.util.setEnumType(CheckTxType, "tendermint.abci.CheckTxType", [
+    { no: 0, name: "NEW" },
+    { no: 1, name: "RECHECK" },
+]);
+export var MisbehaviorType;
+(function (MisbehaviorType) {
+    MisbehaviorType[MisbehaviorType["UNKNOWN"] = 0] = "UNKNOWN";
+    MisbehaviorType[MisbehaviorType["DUPLICATE_VOTE"] = 1] = "DUPLICATE_VOTE";
+    MisbehaviorType[MisbehaviorType["LIGHT_CLIENT_ATTACK"] = 2] = "LIGHT_CLIENT_ATTACK";
+})(MisbehaviorType || (MisbehaviorType = {}));
+proto3.util.setEnumType(MisbehaviorType, "tendermint.abci.MisbehaviorType", [
+    { no: 0, name: "UNKNOWN" },
+    { no: 1, name: "DUPLICATE_VOTE" },
+    { no: 2, name: "LIGHT_CLIENT_ATTACK" },
+]);
+export class Request extends Message {
+    value = { case: undefined };
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Request";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "echo", kind: "message", T: RequestEcho, oneof: "value" },
+        { no: 2, name: "flush", kind: "message", T: RequestFlush, oneof: "value" },
+        { no: 3, name: "info", kind: "message", T: RequestInfo, oneof: "value" },
+        { no: 5, name: "init_chain", kind: "message", T: RequestInitChain, oneof: "value" },
+        { no: 6, name: "query", kind: "message", T: RequestQuery, oneof: "value" },
+        { no: 7, name: "begin_block", kind: "message", T: RequestBeginBlock, oneof: "value" },
+        { no: 8, name: "check_tx", kind: "message", T: RequestCheckTx, oneof: "value" },
+        { no: 9, name: "deliver_tx", kind: "message", T: RequestDeliverTx, oneof: "value" },
+        { no: 10, name: "end_block", kind: "message", T: RequestEndBlock, oneof: "value" },
+        { no: 11, name: "commit", kind: "message", T: RequestCommit, oneof: "value" },
+        { no: 12, name: "list_snapshots", kind: "message", T: RequestListSnapshots, oneof: "value" },
+        { no: 13, name: "offer_snapshot", kind: "message", T: RequestOfferSnapshot, oneof: "value" },
+        { no: 14, name: "load_snapshot_chunk", kind: "message", T: RequestLoadSnapshotChunk, oneof: "value" },
+        { no: 15, name: "apply_snapshot_chunk", kind: "message", T: RequestApplySnapshotChunk, oneof: "value" },
+        { no: 16, name: "prepare_proposal", kind: "message", T: RequestPrepareProposal, oneof: "value" },
+        { no: 17, name: "process_proposal", kind: "message", T: RequestProcessProposal, oneof: "value" },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Request().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Request().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Request().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Request, a, b);
+    }
+}
+export class RequestEcho extends Message {
+    message = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestEcho";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "message", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestEcho().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestEcho().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestEcho().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestEcho, a, b);
+    }
+}
+export class RequestFlush extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestFlush";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new RequestFlush().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestFlush().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestFlush().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestFlush, a, b);
+    }
+}
+export class RequestInfo extends Message {
+    version = "";
+    blockVersion = protoInt64.zero;
+    p2pVersion = protoInt64.zero;
+    abciVersion = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "version", kind: "scalar", T: 9 },
+        { no: 2, name: "block_version", kind: "scalar", T: 4 },
+        { no: 3, name: "p2p_version", kind: "scalar", T: 4 },
+        { no: 4, name: "abci_version", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestInfo, a, b);
+    }
+}
+export class RequestInitChain extends Message {
+    time;
+    chainId = "";
+    consensusParams;
+    validators = [];
+    appStateBytes = new Uint8Array(0);
+    initialHeight = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestInitChain";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "time", kind: "message", T: Timestamp },
+        { no: 2, name: "chain_id", kind: "scalar", T: 9 },
+        { no: 3, name: "consensus_params", kind: "message", T: ConsensusParams },
+        { no: 4, name: "validators", kind: "message", T: ValidatorUpdate, repeated: true },
+        { no: 5, name: "app_state_bytes", kind: "scalar", T: 12 },
+        { no: 6, name: "initial_height", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestInitChain().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestInitChain().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestInitChain().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestInitChain, a, b);
+    }
+}
+export class RequestQuery extends Message {
+    data = new Uint8Array(0);
+    path = "";
+    height = protoInt64.zero;
+    prove = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestQuery";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "data", kind: "scalar", T: 12 },
+        { no: 2, name: "path", kind: "scalar", T: 9 },
+        { no: 3, name: "height", kind: "scalar", T: 3 },
+        { no: 4, name: "prove", kind: "scalar", T: 8 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestQuery().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestQuery().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestQuery().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestQuery, a, b);
+    }
+}
+export class RequestBeginBlock extends Message {
+    hash = new Uint8Array(0);
+    header;
+    lastCommitInfo;
+    byzantineValidators = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestBeginBlock";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "hash", kind: "scalar", T: 12 },
+        { no: 2, name: "header", kind: "message", T: Header },
+        { no: 3, name: "last_commit_info", kind: "message", T: CommitInfo },
+        { no: 4, name: "byzantine_validators", kind: "message", T: Misbehavior, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestBeginBlock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestBeginBlock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestBeginBlock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestBeginBlock, a, b);
+    }
+}
+export class RequestCheckTx extends Message {
+    tx = new Uint8Array(0);
+    type = CheckTxType.NEW;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestCheckTx";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "tx", kind: "scalar", T: 12 },
+        { no: 2, name: "type", kind: "enum", T: proto3.getEnumType(CheckTxType) },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestCheckTx().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestCheckTx().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestCheckTx().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestCheckTx, a, b);
+    }
+}
+export class RequestDeliverTx extends Message {
+    tx = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestDeliverTx";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "tx", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestDeliverTx().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestDeliverTx().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestDeliverTx().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestDeliverTx, a, b);
+    }
+}
+export class RequestEndBlock extends Message {
+    height = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestEndBlock";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "height", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestEndBlock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestEndBlock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestEndBlock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestEndBlock, a, b);
+    }
+}
+export class RequestCommit extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestCommit";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new RequestCommit().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestCommit().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestCommit().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestCommit, a, b);
+    }
+}
+export class RequestListSnapshots extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestListSnapshots";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new RequestListSnapshots().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestListSnapshots().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestListSnapshots().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestListSnapshots, a, b);
+    }
+}
+export class RequestOfferSnapshot extends Message {
+    snapshot;
+    appHash = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestOfferSnapshot";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "snapshot", kind: "message", T: Snapshot },
+        { no: 2, name: "app_hash", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestOfferSnapshot().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestOfferSnapshot().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestOfferSnapshot().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestOfferSnapshot, a, b);
+    }
+}
+export class RequestLoadSnapshotChunk extends Message {
+    height = protoInt64.zero;
+    format = 0;
+    chunk = 0;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestLoadSnapshotChunk";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "height", kind: "scalar", T: 4 },
+        { no: 2, name: "format", kind: "scalar", T: 13 },
+        { no: 3, name: "chunk", kind: "scalar", T: 13 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestLoadSnapshotChunk().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestLoadSnapshotChunk().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestLoadSnapshotChunk().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestLoadSnapshotChunk, a, b);
+    }
+}
+export class RequestApplySnapshotChunk extends Message {
+    index = 0;
+    chunk = new Uint8Array(0);
+    sender = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestApplySnapshotChunk";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "index", kind: "scalar", T: 13 },
+        { no: 2, name: "chunk", kind: "scalar", T: 12 },
+        { no: 3, name: "sender", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestApplySnapshotChunk().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestApplySnapshotChunk().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestApplySnapshotChunk().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestApplySnapshotChunk, a, b);
+    }
+}
+export class RequestPrepareProposal extends Message {
+    maxTxBytes = protoInt64.zero;
+    txs = [];
+    localLastCommit;
+    misbehavior = [];
+    height = protoInt64.zero;
+    time;
+    nextValidatorsHash = new Uint8Array(0);
+    proposerAddress = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestPrepareProposal";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "max_tx_bytes", kind: "scalar", T: 3 },
+        { no: 2, name: "txs", kind: "scalar", T: 12, repeated: true },
+        { no: 3, name: "local_last_commit", kind: "message", T: ExtendedCommitInfo },
+        { no: 4, name: "misbehavior", kind: "message", T: Misbehavior, repeated: true },
+        { no: 5, name: "height", kind: "scalar", T: 3 },
+        { no: 6, name: "time", kind: "message", T: Timestamp },
+        { no: 7, name: "next_validators_hash", kind: "scalar", T: 12 },
+        { no: 8, name: "proposer_address", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestPrepareProposal().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestPrepareProposal().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestPrepareProposal().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestPrepareProposal, a, b);
+    }
+}
+export class RequestProcessProposal extends Message {
+    txs = [];
+    proposedLastCommit;
+    misbehavior = [];
+    hash = new Uint8Array(0);
+    height = protoInt64.zero;
+    time;
+    nextValidatorsHash = new Uint8Array(0);
+    proposerAddress = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.RequestProcessProposal";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "txs", kind: "scalar", T: 12, repeated: true },
+        { no: 2, name: "proposed_last_commit", kind: "message", T: CommitInfo },
+        { no: 3, name: "misbehavior", kind: "message", T: Misbehavior, repeated: true },
+        { no: 4, name: "hash", kind: "scalar", T: 12 },
+        { no: 5, name: "height", kind: "scalar", T: 3 },
+        { no: 6, name: "time", kind: "message", T: Timestamp },
+        { no: 7, name: "next_validators_hash", kind: "scalar", T: 12 },
+        { no: 8, name: "proposer_address", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new RequestProcessProposal().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new RequestProcessProposal().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new RequestProcessProposal().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(RequestProcessProposal, a, b);
+    }
+}
+export class Response extends Message {
+    value = { case: undefined };
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Response";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "exception", kind: "message", T: ResponseException, oneof: "value" },
+        { no: 2, name: "echo", kind: "message", T: ResponseEcho, oneof: "value" },
+        { no: 3, name: "flush", kind: "message", T: ResponseFlush, oneof: "value" },
+        { no: 4, name: "info", kind: "message", T: ResponseInfo, oneof: "value" },
+        { no: 6, name: "init_chain", kind: "message", T: ResponseInitChain, oneof: "value" },
+        { no: 7, name: "query", kind: "message", T: ResponseQuery, oneof: "value" },
+        { no: 8, name: "begin_block", kind: "message", T: ResponseBeginBlock, oneof: "value" },
+        { no: 9, name: "check_tx", kind: "message", T: ResponseCheckTx, oneof: "value" },
+        { no: 10, name: "deliver_tx", kind: "message", T: ResponseDeliverTx, oneof: "value" },
+        { no: 11, name: "end_block", kind: "message", T: ResponseEndBlock, oneof: "value" },
+        { no: 12, name: "commit", kind: "message", T: ResponseCommit, oneof: "value" },
+        { no: 13, name: "list_snapshots", kind: "message", T: ResponseListSnapshots, oneof: "value" },
+        { no: 14, name: "offer_snapshot", kind: "message", T: ResponseOfferSnapshot, oneof: "value" },
+        { no: 15, name: "load_snapshot_chunk", kind: "message", T: ResponseLoadSnapshotChunk, oneof: "value" },
+        { no: 16, name: "apply_snapshot_chunk", kind: "message", T: ResponseApplySnapshotChunk, oneof: "value" },
+        { no: 17, name: "prepare_proposal", kind: "message", T: ResponsePrepareProposal, oneof: "value" },
+        { no: 18, name: "process_proposal", kind: "message", T: ResponseProcessProposal, oneof: "value" },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Response().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Response().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Response().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Response, a, b);
+    }
+}
+export class ResponseException extends Message {
+    error = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseException";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "error", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseException().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseException().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseException().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseException, a, b);
+    }
+}
+export class ResponseEcho extends Message {
+    message = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseEcho";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "message", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseEcho().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseEcho().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseEcho().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseEcho, a, b);
+    }
+}
+export class ResponseFlush extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseFlush";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new ResponseFlush().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseFlush().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseFlush().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseFlush, a, b);
+    }
+}
+export class ResponseInfo extends Message {
+    data = "";
+    version = "";
+    appVersion = protoInt64.zero;
+    lastBlockHeight = protoInt64.zero;
+    lastBlockAppHash = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "data", kind: "scalar", T: 9 },
+        { no: 2, name: "version", kind: "scalar", T: 9 },
+        { no: 3, name: "app_version", kind: "scalar", T: 4 },
+        { no: 4, name: "last_block_height", kind: "scalar", T: 3 },
+        { no: 5, name: "last_block_app_hash", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseInfo, a, b);
+    }
+}
+export class ResponseInitChain extends Message {
+    consensusParams;
+    validators = [];
+    appHash = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseInitChain";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "consensus_params", kind: "message", T: ConsensusParams },
+        { no: 2, name: "validators", kind: "message", T: ValidatorUpdate, repeated: true },
+        { no: 3, name: "app_hash", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseInitChain().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseInitChain().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseInitChain().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseInitChain, a, b);
+    }
+}
+export class ResponseQuery extends Message {
+    code = 0;
+    log = "";
+    info = "";
+    index = protoInt64.zero;
+    key = new Uint8Array(0);
+    value = new Uint8Array(0);
+    proofOps;
+    height = protoInt64.zero;
+    codespace = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseQuery";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "code", kind: "scalar", T: 13 },
+        { no: 3, name: "log", kind: "scalar", T: 9 },
+        { no: 4, name: "info", kind: "scalar", T: 9 },
+        { no: 5, name: "index", kind: "scalar", T: 3 },
+        { no: 6, name: "key", kind: "scalar", T: 12 },
+        { no: 7, name: "value", kind: "scalar", T: 12 },
+        { no: 8, name: "proof_ops", kind: "message", T: ProofOps },
+        { no: 9, name: "height", kind: "scalar", T: 3 },
+        { no: 10, name: "codespace", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseQuery().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseQuery().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseQuery().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseQuery, a, b);
+    }
+}
+export class ResponseBeginBlock extends Message {
+    events = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseBeginBlock";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "events", kind: "message", T: Event, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseBeginBlock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseBeginBlock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseBeginBlock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseBeginBlock, a, b);
+    }
+}
+export class ResponseCheckTx extends Message {
+    code = 0;
+    data = new Uint8Array(0);
+    log = "";
+    info = "";
+    gasWanted = protoInt64.zero;
+    gasUsed = protoInt64.zero;
+    events = [];
+    codespace = "";
+    sender = "";
+    priority = protoInt64.zero;
+    mempoolError = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseCheckTx";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "code", kind: "scalar", T: 13 },
+        { no: 2, name: "data", kind: "scalar", T: 12 },
+        { no: 3, name: "log", kind: "scalar", T: 9 },
+        { no: 4, name: "info", kind: "scalar", T: 9 },
+        { no: 5, name: "gas_wanted", jsonName: "gas_wanted", kind: "scalar", T: 3 },
+        { no: 6, name: "gas_used", jsonName: "gas_used", kind: "scalar", T: 3 },
+        { no: 7, name: "events", kind: "message", T: Event, repeated: true },
+        { no: 8, name: "codespace", kind: "scalar", T: 9 },
+        { no: 9, name: "sender", kind: "scalar", T: 9 },
+        { no: 10, name: "priority", kind: "scalar", T: 3 },
+        { no: 11, name: "mempool_error", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseCheckTx().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseCheckTx().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseCheckTx().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseCheckTx, a, b);
+    }
+}
+export class ResponseDeliverTx extends Message {
+    code = 0;
+    data = new Uint8Array(0);
+    log = "";
+    info = "";
+    gasWanted = protoInt64.zero;
+    gasUsed = protoInt64.zero;
+    events = [];
+    codespace = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseDeliverTx";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "code", kind: "scalar", T: 13 },
+        { no: 2, name: "data", kind: "scalar", T: 12 },
+        { no: 3, name: "log", kind: "scalar", T: 9 },
+        { no: 4, name: "info", kind: "scalar", T: 9 },
+        { no: 5, name: "gas_wanted", jsonName: "gas_wanted", kind: "scalar", T: 3 },
+        { no: 6, name: "gas_used", jsonName: "gas_used", kind: "scalar", T: 3 },
+        { no: 7, name: "events", kind: "message", T: Event, repeated: true },
+        { no: 8, name: "codespace", kind: "scalar", T: 9 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseDeliverTx().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseDeliverTx().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseDeliverTx().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseDeliverTx, a, b);
+    }
+}
+export class ResponseEndBlock extends Message {
+    validatorUpdates = [];
+    consensusParamUpdates;
+    events = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseEndBlock";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "validator_updates", kind: "message", T: ValidatorUpdate, repeated: true },
+        { no: 2, name: "consensus_param_updates", kind: "message", T: ConsensusParams },
+        { no: 3, name: "events", kind: "message", T: Event, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseEndBlock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseEndBlock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseEndBlock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseEndBlock, a, b);
+    }
+}
+export class ResponseCommit extends Message {
+    data = new Uint8Array(0);
+    retainHeight = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseCommit";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 2, name: "data", kind: "scalar", T: 12 },
+        { no: 3, name: "retain_height", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseCommit().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseCommit().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseCommit().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseCommit, a, b);
+    }
+}
+export class ResponseListSnapshots extends Message {
+    snapshots = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseListSnapshots";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "snapshots", kind: "message", T: Snapshot, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseListSnapshots().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseListSnapshots().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseListSnapshots().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseListSnapshots, a, b);
+    }
+}
+export class ResponseOfferSnapshot extends Message {
+    result = ResponseOfferSnapshot_Result.UNKNOWN;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseOfferSnapshot";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "result", kind: "enum", T: proto3.getEnumType(ResponseOfferSnapshot_Result) },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseOfferSnapshot().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseOfferSnapshot().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseOfferSnapshot().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseOfferSnapshot, a, b);
+    }
+}
+export var ResponseOfferSnapshot_Result;
+(function (ResponseOfferSnapshot_Result) {
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["UNKNOWN"] = 0] = "UNKNOWN";
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["ACCEPT"] = 1] = "ACCEPT";
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["ABORT"] = 2] = "ABORT";
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["REJECT"] = 3] = "REJECT";
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["REJECT_FORMAT"] = 4] = "REJECT_FORMAT";
+    ResponseOfferSnapshot_Result[ResponseOfferSnapshot_Result["REJECT_SENDER"] = 5] = "REJECT_SENDER";
+})(ResponseOfferSnapshot_Result || (ResponseOfferSnapshot_Result = {}));
+proto3.util.setEnumType(ResponseOfferSnapshot_Result, "tendermint.abci.ResponseOfferSnapshot.Result", [
+    { no: 0, name: "UNKNOWN" },
+    { no: 1, name: "ACCEPT" },
+    { no: 2, name: "ABORT" },
+    { no: 3, name: "REJECT" },
+    { no: 4, name: "REJECT_FORMAT" },
+    { no: 5, name: "REJECT_SENDER" },
+]);
+export class ResponseLoadSnapshotChunk extends Message {
+    chunk = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseLoadSnapshotChunk";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "chunk", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseLoadSnapshotChunk().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseLoadSnapshotChunk().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseLoadSnapshotChunk().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseLoadSnapshotChunk, a, b);
+    }
+}
+export class ResponseApplySnapshotChunk extends Message {
+    result = ResponseApplySnapshotChunk_Result.UNKNOWN;
+    refetchChunks = [];
+    rejectSenders = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseApplySnapshotChunk";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "result", kind: "enum", T: proto3.getEnumType(ResponseApplySnapshotChunk_Result) },
+        { no: 2, name: "refetch_chunks", kind: "scalar", T: 13, repeated: true },
+        { no: 3, name: "reject_senders", kind: "scalar", T: 9, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseApplySnapshotChunk().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseApplySnapshotChunk().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseApplySnapshotChunk().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseApplySnapshotChunk, a, b);
+    }
+}
+export var ResponseApplySnapshotChunk_Result;
+(function (ResponseApplySnapshotChunk_Result) {
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["UNKNOWN"] = 0] = "UNKNOWN";
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["ACCEPT"] = 1] = "ACCEPT";
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["ABORT"] = 2] = "ABORT";
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["RETRY"] = 3] = "RETRY";
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["RETRY_SNAPSHOT"] = 4] = "RETRY_SNAPSHOT";
+    ResponseApplySnapshotChunk_Result[ResponseApplySnapshotChunk_Result["REJECT_SNAPSHOT"] = 5] = "REJECT_SNAPSHOT";
+})(ResponseApplySnapshotChunk_Result || (ResponseApplySnapshotChunk_Result = {}));
+proto3.util.setEnumType(ResponseApplySnapshotChunk_Result, "tendermint.abci.ResponseApplySnapshotChunk.Result", [
+    { no: 0, name: "UNKNOWN" },
+    { no: 1, name: "ACCEPT" },
+    { no: 2, name: "ABORT" },
+    { no: 3, name: "RETRY" },
+    { no: 4, name: "RETRY_SNAPSHOT" },
+    { no: 5, name: "REJECT_SNAPSHOT" },
+]);
+export class ResponsePrepareProposal extends Message {
+    txs = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponsePrepareProposal";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "txs", kind: "scalar", T: 12, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponsePrepareProposal().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponsePrepareProposal().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponsePrepareProposal().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponsePrepareProposal, a, b);
+    }
+}
+export class ResponseProcessProposal extends Message {
+    status = ResponseProcessProposal_ProposalStatus.UNKNOWN;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ResponseProcessProposal";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(ResponseProcessProposal_ProposalStatus) },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ResponseProcessProposal().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ResponseProcessProposal().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ResponseProcessProposal().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ResponseProcessProposal, a, b);
+    }
+}
+export var ResponseProcessProposal_ProposalStatus;
+(function (ResponseProcessProposal_ProposalStatus) {
+    ResponseProcessProposal_ProposalStatus[ResponseProcessProposal_ProposalStatus["UNKNOWN"] = 0] = "UNKNOWN";
+    ResponseProcessProposal_ProposalStatus[ResponseProcessProposal_ProposalStatus["ACCEPT"] = 1] = "ACCEPT";
+    ResponseProcessProposal_ProposalStatus[ResponseProcessProposal_ProposalStatus["REJECT"] = 2] = "REJECT";
+})(ResponseProcessProposal_ProposalStatus || (ResponseProcessProposal_ProposalStatus = {}));
+proto3.util.setEnumType(ResponseProcessProposal_ProposalStatus, "tendermint.abci.ResponseProcessProposal.ProposalStatus", [
+    { no: 0, name: "UNKNOWN" },
+    { no: 1, name: "ACCEPT" },
+    { no: 2, name: "REJECT" },
+]);
+export class CommitInfo extends Message {
+    round = 0;
+    votes = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.CommitInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "round", kind: "scalar", T: 5 },
+        { no: 2, name: "votes", kind: "message", T: VoteInfo, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new CommitInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CommitInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CommitInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CommitInfo, a, b);
+    }
+}
+export class ExtendedCommitInfo extends Message {
+    round = 0;
+    votes = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ExtendedCommitInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "round", kind: "scalar", T: 5 },
+        { no: 2, name: "votes", kind: "message", T: ExtendedVoteInfo, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ExtendedCommitInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ExtendedCommitInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ExtendedCommitInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ExtendedCommitInfo, a, b);
+    }
+}
+export class Event extends Message {
+    type = "";
+    attributes = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Event";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "type", kind: "scalar", T: 9 },
+        { no: 2, name: "attributes", kind: "message", T: EventAttribute, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Event().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Event().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Event().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Event, a, b);
+    }
+}
+export class EventAttribute extends Message {
+    key = "";
+    value = "";
+    index = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.EventAttribute";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "key", kind: "scalar", T: 9 },
+        { no: 2, name: "value", kind: "scalar", T: 9 },
+        { no: 3, name: "index", kind: "scalar", T: 8 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new EventAttribute().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new EventAttribute().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new EventAttribute().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(EventAttribute, a, b);
+    }
+}
+export class TxResult extends Message {
+    height = protoInt64.zero;
+    index = 0;
+    tx = new Uint8Array(0);
+    result;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.TxResult";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "height", kind: "scalar", T: 3 },
+        { no: 2, name: "index", kind: "scalar", T: 13 },
+        { no: 3, name: "tx", kind: "scalar", T: 12 },
+        { no: 4, name: "result", kind: "message", T: ResponseDeliverTx },
+    ]);
+    static fromBinary(bytes, options) {
+        return new TxResult().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TxResult().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TxResult().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TxResult, a, b);
+    }
+}
+export class Validator extends Message {
+    address = new Uint8Array(0);
+    power = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Validator";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "address", kind: "scalar", T: 12 },
+        { no: 3, name: "power", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Validator().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Validator().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Validator().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Validator, a, b);
+    }
+}
+export class ValidatorUpdate extends Message {
+    pubKey;
+    power = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ValidatorUpdate";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "pub_key", kind: "message", T: PublicKey },
+        { no: 2, name: "power", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ValidatorUpdate().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ValidatorUpdate().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ValidatorUpdate().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ValidatorUpdate, a, b);
+    }
+}
+export class VoteInfo extends Message {
+    validator;
+    signedLastBlock = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.VoteInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "validator", kind: "message", T: Validator },
+        { no: 2, name: "signed_last_block", kind: "scalar", T: 8 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new VoteInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new VoteInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new VoteInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(VoteInfo, a, b);
+    }
+}
+export class ExtendedVoteInfo extends Message {
+    validator;
+    signedLastBlock = false;
+    voteExtension = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.ExtendedVoteInfo";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "validator", kind: "message", T: Validator },
+        { no: 2, name: "signed_last_block", kind: "scalar", T: 8 },
+        { no: 3, name: "vote_extension", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ExtendedVoteInfo().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ExtendedVoteInfo().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ExtendedVoteInfo().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ExtendedVoteInfo, a, b);
+    }
+}
+export class Misbehavior extends Message {
+    type = MisbehaviorType.UNKNOWN;
+    validator;
+    height = protoInt64.zero;
+    time;
+    totalVotingPower = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Misbehavior";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(MisbehaviorType) },
+        { no: 2, name: "validator", kind: "message", T: Validator },
+        { no: 3, name: "height", kind: "scalar", T: 3 },
+        { no: 4, name: "time", kind: "message", T: Timestamp },
+        { no: 5, name: "total_voting_power", kind: "scalar", T: 3 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Misbehavior().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Misbehavior().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Misbehavior().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Misbehavior, a, b);
+    }
+}
+export class Snapshot extends Message {
+    height = protoInt64.zero;
+    format = 0;
+    chunks = 0;
+    hash = new Uint8Array(0);
+    metadata = new Uint8Array(0);
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "tendermint.abci.Snapshot";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "height", kind: "scalar", T: 4 },
+        { no: 2, name: "format", kind: "scalar", T: 13 },
+        { no: 3, name: "chunks", kind: "scalar", T: 13 },
+        { no: 4, name: "hash", kind: "scalar", T: 12 },
+        { no: 5, name: "metadata", kind: "scalar", T: 12 },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Snapshot().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Snapshot().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Snapshot().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Snapshot, a, b);
+    }
+}
+//# sourceMappingURL=types_pb.js.map