@agoric/client-utils 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

package/dist/codegen/tendermint/abci/types.js

@@ -0,0 +1,1924 @@
+//@ts-nocheck
+import { Header } from '../types/types.js';
+import { ProofOps } from '../crypto/proof.js';
+import { ConsensusParams, } from '../types/params.js';
+import { PublicKey } from '../crypto/keys.js';
+import { Timestamp, } from '../../google/protobuf/timestamp.js';
+import { BinaryReader, BinaryWriter } from '../../binary.js';
+import { isSet, fromJsonTimestamp, fromTimestamp } from '../../helpers.js';
+import { decodeBase64 as bytesFromBase64 } from '@endo/base64';
+import { encodeBase64 as base64FromBytes } from '@endo/base64';
+import {} from '../../json-safe.js';
+export var CheckTxType;
+(function (CheckTxType) {
+    CheckTxType[CheckTxType["NEW"] = 0] = "NEW";
+    CheckTxType[CheckTxType["RECHECK"] = 1] = "RECHECK";
+    CheckTxType[CheckTxType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CheckTxType || (CheckTxType = {}));
+export const CheckTxTypeSDKType = CheckTxType;
+export function checkTxTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'NEW':
+            return CheckTxType.NEW;
+        case 1:
+        case 'RECHECK':
+            return CheckTxType.RECHECK;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return CheckTxType.UNRECOGNIZED;
+    }
+}
+export function checkTxTypeToJSON(object) {
+    switch (object) {
+        case CheckTxType.NEW:
+            return 'NEW';
+        case CheckTxType.RECHECK:
+            return 'RECHECK';
+        case CheckTxType.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
+export var EvidenceType;
+(function (EvidenceType) {
+    EvidenceType[EvidenceType["UNKNOWN"] = 0] = "UNKNOWN";
+    EvidenceType[EvidenceType["DUPLICATE_VOTE"] = 1] = "DUPLICATE_VOTE";
+    EvidenceType[EvidenceType["LIGHT_CLIENT_ATTACK"] = 2] = "LIGHT_CLIENT_ATTACK";
+    EvidenceType[EvidenceType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EvidenceType || (EvidenceType = {}));
+export const EvidenceTypeSDKType = EvidenceType;
+export function evidenceTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'UNKNOWN':
+            return EvidenceType.UNKNOWN;
+        case 1:
+        case 'DUPLICATE_VOTE':
+            return EvidenceType.DUPLICATE_VOTE;
+        case 2:
+        case 'LIGHT_CLIENT_ATTACK':
+            return EvidenceType.LIGHT_CLIENT_ATTACK;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return EvidenceType.UNRECOGNIZED;
+    }
+}
+export function evidenceTypeToJSON(object) {
+    switch (object) {
+        case EvidenceType.UNKNOWN:
+            return 'UNKNOWN';
+        case EvidenceType.DUPLICATE_VOTE:
+            return 'DUPLICATE_VOTE';
+        case EvidenceType.LIGHT_CLIENT_ATTACK:
+            return 'LIGHT_CLIENT_ATTACK';
+        case EvidenceType.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
+function createBaseRequestQuery() {
+    return {
+        data: new Uint8Array(),
+        path: '',
+        height: BigInt(0),
+        prove: false,
+    };
+}
+export const RequestQuery = {
+    typeUrl: '/tendermint.abci.RequestQuery',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.data.length !== 0) {
+            writer.uint32(10).bytes(message.data);
+        }
+        if (message.path !== '') {
+            writer.uint32(18).string(message.path);
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(24).int64(message.height);
+        }
+        if (message.prove === true) {
+            writer.uint32(32).bool(message.prove);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestQuery();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.data = reader.bytes();
+                    break;
+                case 2:
+                    message.path = reader.string();
+                    break;
+                case 3:
+                    message.height = reader.int64();
+                    break;
+                case 4:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+            path: isSet(object.path) ? String(object.path) : '',
+            height: isSet(object.height)
+                ? BigInt(object.height.toString())
+                : BigInt(0),
+            prove: isSet(object.prove) ? Boolean(object.prove) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        message.path !== undefined && (obj.path = message.path);
+        message.height !== undefined &&
+            (obj.height = (message.height || BigInt(0)).toString());
+        message.prove !== undefined && (obj.prove = message.prove);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestQuery();
+        message.data = object.data ?? new Uint8Array();
+        message.path = object.path ?? '';
+        message.height =
+            object.height !== undefined && object.height !== null
+                ? BigInt(object.height.toString())
+                : BigInt(0);
+        message.prove = object.prove ?? false;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestQuery.decode(message.value);
+    },
+    toProto(message) {
+        return RequestQuery.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestQuery',
+            value: RequestQuery.encode(message).finish(),
+        };
+    },
+};
+function createBaseRequestBeginBlock() {
+    return {
+        hash: new Uint8Array(),
+        header: Header.fromPartial({}),
+        lastCommitInfo: LastCommitInfo.fromPartial({}),
+        byzantineValidators: [],
+    };
+}
+export const RequestBeginBlock = {
+    typeUrl: '/tendermint.abci.RequestBeginBlock',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.hash.length !== 0) {
+            writer.uint32(10).bytes(message.hash);
+        }
+        if (message.header !== undefined) {
+            Header.encode(message.header, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.lastCommitInfo !== undefined) {
+            LastCommitInfo.encode(message.lastCommitInfo, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.byzantineValidators) {
+            Evidence.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestBeginBlock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.hash = reader.bytes();
+                    break;
+                case 2:
+                    message.header = Header.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.lastCommitInfo = LastCommitInfo.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.byzantineValidators.push(Evidence.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            hash: isSet(object.hash)
+                ? bytesFromBase64(object.hash)
+                : new Uint8Array(),
+            header: isSet(object.header) ? Header.fromJSON(object.header) : undefined,
+            lastCommitInfo: isSet(object.lastCommitInfo)
+                ? LastCommitInfo.fromJSON(object.lastCommitInfo)
+                : undefined,
+            byzantineValidators: Array.isArray(object?.byzantineValidators)
+                ? object.byzantineValidators.map((e) => Evidence.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.hash !== undefined &&
+            (obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
+        message.header !== undefined &&
+            (obj.header = message.header ? Header.toJSON(message.header) : undefined);
+        message.lastCommitInfo !== undefined &&
+            (obj.lastCommitInfo = message.lastCommitInfo
+                ? LastCommitInfo.toJSON(message.lastCommitInfo)
+                : undefined);
+        if (message.byzantineValidators) {
+            obj.byzantineValidators = message.byzantineValidators.map(e => e ? Evidence.toJSON(e) : undefined);
+        }
+        else {
+            obj.byzantineValidators = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestBeginBlock();
+        message.hash = object.hash ?? new Uint8Array();
+        message.header =
+            object.header !== undefined && object.header !== null
+                ? Header.fromPartial(object.header)
+                : undefined;
+        message.lastCommitInfo =
+            object.lastCommitInfo !== undefined && object.lastCommitInfo !== null
+                ? LastCommitInfo.fromPartial(object.lastCommitInfo)
+                : undefined;
+        message.byzantineValidators =
+            object.byzantineValidators?.map(e => Evidence.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestBeginBlock.decode(message.value);
+    },
+    toProto(message) {
+        return RequestBeginBlock.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestBeginBlock',
+            value: RequestBeginBlock.encode(message).finish(),
+        };
+    },
+};
+function createBaseRequestCheckTx() {
+    return {
+        tx: new Uint8Array(),
+        type: 0,
+    };
+}
+export const RequestCheckTx = {
+    typeUrl: '/tendermint.abci.RequestCheckTx',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.tx.length !== 0) {
+            writer.uint32(10).bytes(message.tx);
+        }
+        if (message.type !== 0) {
+            writer.uint32(16).int32(message.type);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestCheckTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.tx = reader.bytes();
+                    break;
+                case 2:
+                    message.type = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            tx: isSet(object.tx) ? bytesFromBase64(object.tx) : new Uint8Array(),
+            type: isSet(object.type) ? checkTxTypeFromJSON(object.type) : -1,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.tx !== undefined &&
+            (obj.tx = base64FromBytes(message.tx !== undefined ? message.tx : new Uint8Array()));
+        message.type !== undefined && (obj.type = checkTxTypeToJSON(message.type));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestCheckTx();
+        message.tx = object.tx ?? new Uint8Array();
+        message.type = object.type ?? 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestCheckTx.decode(message.value);
+    },
+    toProto(message) {
+        return RequestCheckTx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestCheckTx',
+            value: RequestCheckTx.encode(message).finish(),
+        };
+    },
+};
+function createBaseRequestDeliverTx() {
+    return {
+        tx: new Uint8Array(),
+    };
+}
+export const RequestDeliverTx = {
+    typeUrl: '/tendermint.abci.RequestDeliverTx',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.tx.length !== 0) {
+            writer.uint32(10).bytes(message.tx);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestDeliverTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.tx = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            tx: isSet(object.tx) ? bytesFromBase64(object.tx) : new Uint8Array(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.tx !== undefined &&
+            (obj.tx = base64FromBytes(message.tx !== undefined ? message.tx : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestDeliverTx();
+        message.tx = object.tx ?? new Uint8Array();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestDeliverTx.decode(message.value);
+    },
+    toProto(message) {
+        return RequestDeliverTx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestDeliverTx',
+            value: RequestDeliverTx.encode(message).finish(),
+        };
+    },
+};
+function createBaseRequestEndBlock() {
+    return {
+        height: BigInt(0),
+    };
+}
+export const RequestEndBlock = {
+    typeUrl: '/tendermint.abci.RequestEndBlock',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.height !== BigInt(0)) {
+            writer.uint32(8).int64(message.height);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestEndBlock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.height = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            height: isSet(object.height)
+                ? BigInt(object.height.toString())
+                : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.height !== undefined &&
+            (obj.height = (message.height || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRequestEndBlock();
+        message.height =
+            object.height !== undefined && object.height !== null
+                ? BigInt(object.height.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestEndBlock.decode(message.value);
+    },
+    toProto(message) {
+        return RequestEndBlock.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestEndBlock',
+            value: RequestEndBlock.encode(message).finish(),
+        };
+    },
+};
+function createBaseRequestCommit() {
+    return {};
+}
+export const RequestCommit = {
+    typeUrl: '/tendermint.abci.RequestCommit',
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRequestCommit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    fromPartial(_) {
+        const message = createBaseRequestCommit();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return RequestCommit.decode(message.value);
+    },
+    toProto(message) {
+        return RequestCommit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.RequestCommit',
+            value: RequestCommit.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseQuery() {
+    return {
+        code: 0,
+        log: '',
+        info: '',
+        index: BigInt(0),
+        key: new Uint8Array(),
+        value: new Uint8Array(),
+        proofOps: undefined,
+        height: BigInt(0),
+        codespace: '',
+    };
+}
+export const ResponseQuery = {
+    typeUrl: '/tendermint.abci.ResponseQuery',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.code !== 0) {
+            writer.uint32(8).uint32(message.code);
+        }
+        if (message.log !== '') {
+            writer.uint32(26).string(message.log);
+        }
+        if (message.info !== '') {
+            writer.uint32(34).string(message.info);
+        }
+        if (message.index !== BigInt(0)) {
+            writer.uint32(40).int64(message.index);
+        }
+        if (message.key.length !== 0) {
+            writer.uint32(50).bytes(message.key);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(58).bytes(message.value);
+        }
+        if (message.proofOps !== undefined) {
+            ProofOps.encode(message.proofOps, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(72).int64(message.height);
+        }
+        if (message.codespace !== '') {
+            writer.uint32(82).string(message.codespace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseQuery();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.uint32();
+                    break;
+                case 3:
+                    message.log = reader.string();
+                    break;
+                case 4:
+                    message.info = reader.string();
+                    break;
+                case 5:
+                    message.index = reader.int64();
+                    break;
+                case 6:
+                    message.key = reader.bytes();
+                    break;
+                case 7:
+                    message.value = reader.bytes();
+                    break;
+                case 8:
+                    message.proofOps = ProofOps.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.height = reader.int64();
+                    break;
+                case 10:
+                    message.codespace = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: isSet(object.code) ? Number(object.code) : 0,
+            log: isSet(object.log) ? String(object.log) : '',
+            info: isSet(object.info) ? String(object.info) : '',
+            index: isSet(object.index) ? BigInt(object.index.toString()) : BigInt(0),
+            key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
+            value: isSet(object.value)
+                ? bytesFromBase64(object.value)
+                : new Uint8Array(),
+            proofOps: isSet(object.proofOps)
+                ? ProofOps.fromJSON(object.proofOps)
+                : undefined,
+            height: isSet(object.height)
+                ? BigInt(object.height.toString())
+                : BigInt(0),
+            codespace: isSet(object.codespace) ? String(object.codespace) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.code !== undefined && (obj.code = Math.round(message.code));
+        message.log !== undefined && (obj.log = message.log);
+        message.info !== undefined && (obj.info = message.info);
+        message.index !== undefined &&
+            (obj.index = (message.index || BigInt(0)).toString());
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        message.value !== undefined &&
+            (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
+        message.proofOps !== undefined &&
+            (obj.proofOps = message.proofOps
+                ? ProofOps.toJSON(message.proofOps)
+                : undefined);
+        message.height !== undefined &&
+            (obj.height = (message.height || BigInt(0)).toString());
+        message.codespace !== undefined && (obj.codespace = message.codespace);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseQuery();
+        message.code = object.code ?? 0;
+        message.log = object.log ?? '';
+        message.info = object.info ?? '';
+        message.index =
+            object.index !== undefined && object.index !== null
+                ? BigInt(object.index.toString())
+                : BigInt(0);
+        message.key = object.key ?? new Uint8Array();
+        message.value = object.value ?? new Uint8Array();
+        message.proofOps =
+            object.proofOps !== undefined && object.proofOps !== null
+                ? ProofOps.fromPartial(object.proofOps)
+                : undefined;
+        message.height =
+            object.height !== undefined && object.height !== null
+                ? BigInt(object.height.toString())
+                : BigInt(0);
+        message.codespace = object.codespace ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseQuery.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseQuery.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseQuery',
+            value: ResponseQuery.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseBeginBlock() {
+    return {
+        events: [],
+    };
+}
+export const ResponseBeginBlock = {
+    typeUrl: '/tendermint.abci.ResponseBeginBlock',
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.events) {
+            Event.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseBeginBlock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.events.push(Event.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            events: Array.isArray(object?.events)
+                ? object.events.map((e) => Event.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.events) {
+            obj.events = message.events.map(e => (e ? Event.toJSON(e) : undefined));
+        }
+        else {
+            obj.events = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseBeginBlock();
+        message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseBeginBlock.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseBeginBlock.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseBeginBlock',
+            value: ResponseBeginBlock.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseCheckTx() {
+    return {
+        code: 0,
+        data: new Uint8Array(),
+        log: '',
+        info: '',
+        gasWanted: BigInt(0),
+        gasUsed: BigInt(0),
+        events: [],
+        codespace: '',
+    };
+}
+export const ResponseCheckTx = {
+    typeUrl: '/tendermint.abci.ResponseCheckTx',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.code !== 0) {
+            writer.uint32(8).uint32(message.code);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        if (message.log !== '') {
+            writer.uint32(26).string(message.log);
+        }
+        if (message.info !== '') {
+            writer.uint32(34).string(message.info);
+        }
+        if (message.gasWanted !== BigInt(0)) {
+            writer.uint32(40).int64(message.gasWanted);
+        }
+        if (message.gasUsed !== BigInt(0)) {
+            writer.uint32(48).int64(message.gasUsed);
+        }
+        for (const v of message.events) {
+            Event.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.codespace !== '') {
+            writer.uint32(66).string(message.codespace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseCheckTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.uint32();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                case 3:
+                    message.log = reader.string();
+                    break;
+                case 4:
+                    message.info = reader.string();
+                    break;
+                case 5:
+                    message.gasWanted = reader.int64();
+                    break;
+                case 6:
+                    message.gasUsed = reader.int64();
+                    break;
+                case 7:
+                    message.events.push(Event.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.codespace = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: isSet(object.code) ? Number(object.code) : 0,
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+            log: isSet(object.log) ? String(object.log) : '',
+            info: isSet(object.info) ? String(object.info) : '',
+            gasWanted: isSet(object.gas_wanted)
+                ? BigInt(object.gas_wanted.toString())
+                : BigInt(0),
+            gasUsed: isSet(object.gas_used)
+                ? BigInt(object.gas_used.toString())
+                : BigInt(0),
+            events: Array.isArray(object?.events)
+                ? object.events.map((e) => Event.fromJSON(e))
+                : [],
+            codespace: isSet(object.codespace) ? String(object.codespace) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.code !== undefined && (obj.code = Math.round(message.code));
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        message.log !== undefined && (obj.log = message.log);
+        message.info !== undefined && (obj.info = message.info);
+        message.gasWanted !== undefined &&
+            (obj.gas_wanted = (message.gasWanted || BigInt(0)).toString());
+        message.gasUsed !== undefined &&
+            (obj.gas_used = (message.gasUsed || BigInt(0)).toString());
+        if (message.events) {
+            obj.events = message.events.map(e => (e ? Event.toJSON(e) : undefined));
+        }
+        else {
+            obj.events = [];
+        }
+        message.codespace !== undefined && (obj.codespace = message.codespace);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseCheckTx();
+        message.code = object.code ?? 0;
+        message.data = object.data ?? new Uint8Array();
+        message.log = object.log ?? '';
+        message.info = object.info ?? '';
+        message.gasWanted =
+            object.gasWanted !== undefined && object.gasWanted !== null
+                ? BigInt(object.gasWanted.toString())
+                : BigInt(0);
+        message.gasUsed =
+            object.gasUsed !== undefined && object.gasUsed !== null
+                ? BigInt(object.gasUsed.toString())
+                : BigInt(0);
+        message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+        message.codespace = object.codespace ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseCheckTx.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseCheckTx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseCheckTx',
+            value: ResponseCheckTx.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseDeliverTx() {
+    return {
+        code: 0,
+        data: new Uint8Array(),
+        log: '',
+        info: '',
+        gasWanted: BigInt(0),
+        gasUsed: BigInt(0),
+        events: [],
+        codespace: '',
+    };
+}
+export const ResponseDeliverTx = {
+    typeUrl: '/tendermint.abci.ResponseDeliverTx',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.code !== 0) {
+            writer.uint32(8).uint32(message.code);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        if (message.log !== '') {
+            writer.uint32(26).string(message.log);
+        }
+        if (message.info !== '') {
+            writer.uint32(34).string(message.info);
+        }
+        if (message.gasWanted !== BigInt(0)) {
+            writer.uint32(40).int64(message.gasWanted);
+        }
+        if (message.gasUsed !== BigInt(0)) {
+            writer.uint32(48).int64(message.gasUsed);
+        }
+        for (const v of message.events) {
+            Event.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.codespace !== '') {
+            writer.uint32(66).string(message.codespace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseDeliverTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.uint32();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                case 3:
+                    message.log = reader.string();
+                    break;
+                case 4:
+                    message.info = reader.string();
+                    break;
+                case 5:
+                    message.gasWanted = reader.int64();
+                    break;
+                case 6:
+                    message.gasUsed = reader.int64();
+                    break;
+                case 7:
+                    message.events.push(Event.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.codespace = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: isSet(object.code) ? Number(object.code) : 0,
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+            log: isSet(object.log) ? String(object.log) : '',
+            info: isSet(object.info) ? String(object.info) : '',
+            gasWanted: isSet(object.gas_wanted)
+                ? BigInt(object.gas_wanted.toString())
+                : BigInt(0),
+            gasUsed: isSet(object.gas_used)
+                ? BigInt(object.gas_used.toString())
+                : BigInt(0),
+            events: Array.isArray(object?.events)
+                ? object.events.map((e) => Event.fromJSON(e))
+                : [],
+            codespace: isSet(object.codespace) ? String(object.codespace) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.code !== undefined && (obj.code = Math.round(message.code));
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        message.log !== undefined && (obj.log = message.log);
+        message.info !== undefined && (obj.info = message.info);
+        message.gasWanted !== undefined &&
+            (obj.gas_wanted = (message.gasWanted || BigInt(0)).toString());
+        message.gasUsed !== undefined &&
+            (obj.gas_used = (message.gasUsed || BigInt(0)).toString());
+        if (message.events) {
+            obj.events = message.events.map(e => (e ? Event.toJSON(e) : undefined));
+        }
+        else {
+            obj.events = [];
+        }
+        message.codespace !== undefined && (obj.codespace = message.codespace);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseDeliverTx();
+        message.code = object.code ?? 0;
+        message.data = object.data ?? new Uint8Array();
+        message.log = object.log ?? '';
+        message.info = object.info ?? '';
+        message.gasWanted =
+            object.gasWanted !== undefined && object.gasWanted !== null
+                ? BigInt(object.gasWanted.toString())
+                : BigInt(0);
+        message.gasUsed =
+            object.gasUsed !== undefined && object.gasUsed !== null
+                ? BigInt(object.gasUsed.toString())
+                : BigInt(0);
+        message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+        message.codespace = object.codespace ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseDeliverTx.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseDeliverTx.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseDeliverTx',
+            value: ResponseDeliverTx.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseEndBlock() {
+    return {
+        validatorUpdates: [],
+        consensusParamUpdates: undefined,
+        events: [],
+    };
+}
+export const ResponseEndBlock = {
+    typeUrl: '/tendermint.abci.ResponseEndBlock',
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.validatorUpdates) {
+            ValidatorUpdate.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.consensusParamUpdates !== undefined) {
+            ConsensusParams.encode(message.consensusParamUpdates, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.events) {
+            Event.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseEndBlock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validatorUpdates.push(ValidatorUpdate.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.consensusParamUpdates = ConsensusParams.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.events.push(Event.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            validatorUpdates: Array.isArray(object?.validatorUpdates)
+                ? object.validatorUpdates.map((e) => ValidatorUpdate.fromJSON(e))
+                : [],
+            consensusParamUpdates: isSet(object.consensusParamUpdates)
+                ? ConsensusParams.fromJSON(object.consensusParamUpdates)
+                : undefined,
+            events: Array.isArray(object?.events)
+                ? object.events.map((e) => Event.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.validatorUpdates) {
+            obj.validatorUpdates = message.validatorUpdates.map(e => e ? ValidatorUpdate.toJSON(e) : undefined);
+        }
+        else {
+            obj.validatorUpdates = [];
+        }
+        message.consensusParamUpdates !== undefined &&
+            (obj.consensusParamUpdates = message.consensusParamUpdates
+                ? ConsensusParams.toJSON(message.consensusParamUpdates)
+                : undefined);
+        if (message.events) {
+            obj.events = message.events.map(e => (e ? Event.toJSON(e) : undefined));
+        }
+        else {
+            obj.events = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseEndBlock();
+        message.validatorUpdates =
+            object.validatorUpdates?.map(e => ValidatorUpdate.fromPartial(e)) || [];
+        message.consensusParamUpdates =
+            object.consensusParamUpdates !== undefined &&
+                object.consensusParamUpdates !== null
+                ? ConsensusParams.fromPartial(object.consensusParamUpdates)
+                : undefined;
+        message.events = object.events?.map(e => Event.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseEndBlock.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseEndBlock.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseEndBlock',
+            value: ResponseEndBlock.encode(message).finish(),
+        };
+    },
+};
+function createBaseResponseCommit() {
+    return {
+        data: new Uint8Array(),
+        retainHeight: BigInt(0),
+    };
+}
+export const ResponseCommit = {
+    typeUrl: '/tendermint.abci.ResponseCommit',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        if (message.retainHeight !== BigInt(0)) {
+            writer.uint32(24).int64(message.retainHeight);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResponseCommit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                case 3:
+                    message.retainHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+            retainHeight: isSet(object.retainHeight)
+                ? BigInt(object.retainHeight.toString())
+                : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        message.retainHeight !== undefined &&
+            (obj.retainHeight = (message.retainHeight || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseResponseCommit();
+        message.data = object.data ?? new Uint8Array();
+        message.retainHeight =
+            object.retainHeight !== undefined && object.retainHeight !== null
+                ? BigInt(object.retainHeight.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ResponseCommit.decode(message.value);
+    },
+    toProto(message) {
+        return ResponseCommit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ResponseCommit',
+            value: ResponseCommit.encode(message).finish(),
+        };
+    },
+};
+function createBaseLastCommitInfo() {
+    return {
+        round: 0,
+        votes: [],
+    };
+}
+export const LastCommitInfo = {
+    typeUrl: '/tendermint.abci.LastCommitInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.round !== 0) {
+            writer.uint32(8).int32(message.round);
+        }
+        for (const v of message.votes) {
+            VoteInfo.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLastCommitInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.round = reader.int32();
+                    break;
+                case 2:
+                    message.votes.push(VoteInfo.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            round: isSet(object.round) ? Number(object.round) : 0,
+            votes: Array.isArray(object?.votes)
+                ? object.votes.map((e) => VoteInfo.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.round !== undefined && (obj.round = Math.round(message.round));
+        if (message.votes) {
+            obj.votes = message.votes.map(e => (e ? VoteInfo.toJSON(e) : undefined));
+        }
+        else {
+            obj.votes = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseLastCommitInfo();
+        message.round = object.round ?? 0;
+        message.votes = object.votes?.map(e => VoteInfo.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return LastCommitInfo.decode(message.value);
+    },
+    toProto(message) {
+        return LastCommitInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.LastCommitInfo',
+            value: LastCommitInfo.encode(message).finish(),
+        };
+    },
+};
+function createBaseEvent() {
+    return {
+        type: '',
+        attributes: [],
+    };
+}
+export const Event = {
+    typeUrl: '/tendermint.abci.Event',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== '') {
+            writer.uint32(10).string(message.type);
+        }
+        for (const v of message.attributes) {
+            EventAttribute.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEvent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.attributes.push(EventAttribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            type: isSet(object.type) ? String(object.type) : '',
+            attributes: Array.isArray(object?.attributes)
+                ? object.attributes.map((e) => EventAttribute.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.type !== undefined && (obj.type = message.type);
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? EventAttribute.toJSON(e) : undefined);
+        }
+        else {
+            obj.attributes = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseEvent();
+        message.type = object.type ?? '';
+        message.attributes =
+            object.attributes?.map(e => EventAttribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return Event.decode(message.value);
+    },
+    toProto(message) {
+        return Event.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.Event',
+            value: Event.encode(message).finish(),
+        };
+    },
+};
+function createBaseEventAttribute() {
+    return {
+        key: new Uint8Array(),
+        value: new Uint8Array(),
+        index: false,
+    };
+}
+export const EventAttribute = {
+    typeUrl: '/tendermint.abci.EventAttribute',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        if (message.index === true) {
+            writer.uint32(24).bool(message.index);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEventAttribute();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                case 2:
+                    message.value = reader.bytes();
+                    break;
+                case 3:
+                    message.index = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
+            value: isSet(object.value)
+                ? bytesFromBase64(object.value)
+                : new Uint8Array(),
+            index: isSet(object.index) ? Boolean(object.index) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        message.value !== undefined &&
+            (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
+        message.index !== undefined && (obj.index = message.index);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseEventAttribute();
+        message.key = object.key ?? new Uint8Array();
+        message.value = object.value ?? new Uint8Array();
+        message.index = object.index ?? false;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return EventAttribute.decode(message.value);
+    },
+    toProto(message) {
+        return EventAttribute.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.EventAttribute',
+            value: EventAttribute.encode(message).finish(),
+        };
+    },
+};
+function createBaseTxResult() {
+    return {
+        height: BigInt(0),
+        index: 0,
+        tx: new Uint8Array(),
+        result: ResponseDeliverTx.fromPartial({}),
+    };
+}
+export const TxResult = {
+    typeUrl: '/tendermint.abci.TxResult',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.height !== BigInt(0)) {
+            writer.uint32(8).int64(message.height);
+        }
+        if (message.index !== 0) {
+            writer.uint32(16).uint32(message.index);
+        }
+        if (message.tx.length !== 0) {
+            writer.uint32(26).bytes(message.tx);
+        }
+        if (message.result !== undefined) {
+            ResponseDeliverTx.encode(message.result, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTxResult();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.height = reader.int64();
+                    break;
+                case 2:
+                    message.index = reader.uint32();
+                    break;
+                case 3:
+                    message.tx = reader.bytes();
+                    break;
+                case 4:
+                    message.result = ResponseDeliverTx.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            height: isSet(object.height)
+                ? BigInt(object.height.toString())
+                : BigInt(0),
+            index: isSet(object.index) ? Number(object.index) : 0,
+            tx: isSet(object.tx) ? bytesFromBase64(object.tx) : new Uint8Array(),
+            result: isSet(object.result)
+                ? ResponseDeliverTx.fromJSON(object.result)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.height !== undefined &&
+            (obj.height = (message.height || BigInt(0)).toString());
+        message.index !== undefined && (obj.index = Math.round(message.index));
+        message.tx !== undefined &&
+            (obj.tx = base64FromBytes(message.tx !== undefined ? message.tx : new Uint8Array()));
+        message.result !== undefined &&
+            (obj.result = message.result
+                ? ResponseDeliverTx.toJSON(message.result)
+                : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseTxResult();
+        message.height =
+            object.height !== undefined && object.height !== null
+                ? BigInt(object.height.toString())
+                : BigInt(0);
+        message.index = object.index ?? 0;
+        message.tx = object.tx ?? new Uint8Array();
+        message.result =
+            object.result !== undefined && object.result !== null
+                ? ResponseDeliverTx.fromPartial(object.result)
+                : undefined;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return TxResult.decode(message.value);
+    },
+    toProto(message) {
+        return TxResult.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.TxResult',
+            value: TxResult.encode(message).finish(),
+        };
+    },
+};
+function createBaseValidator() {
+    return {
+        address: new Uint8Array(),
+        power: BigInt(0),
+    };
+}
+export const Validator = {
+    typeUrl: '/tendermint.abci.Validator',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address.length !== 0) {
+            writer.uint32(10).bytes(message.address);
+        }
+        if (message.power !== BigInt(0)) {
+            writer.uint32(24).int64(message.power);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseValidator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.bytes();
+                    break;
+                case 3:
+                    message.power = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            address: isSet(object.address)
+                ? bytesFromBase64(object.address)
+                : new Uint8Array(),
+            power: isSet(object.power) ? BigInt(object.power.toString()) : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.address !== undefined &&
+            (obj.address = base64FromBytes(message.address !== undefined ? message.address : new Uint8Array()));
+        message.power !== undefined &&
+            (obj.power = (message.power || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseValidator();
+        message.address = object.address ?? new Uint8Array();
+        message.power =
+            object.power !== undefined && object.power !== null
+                ? BigInt(object.power.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return Validator.decode(message.value);
+    },
+    toProto(message) {
+        return Validator.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.Validator',
+            value: Validator.encode(message).finish(),
+        };
+    },
+};
+function createBaseValidatorUpdate() {
+    return {
+        pubKey: PublicKey.fromPartial({}),
+        power: BigInt(0),
+    };
+}
+export const ValidatorUpdate = {
+    typeUrl: '/tendermint.abci.ValidatorUpdate',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pubKey !== undefined) {
+            PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.power !== BigInt(0)) {
+            writer.uint32(16).int64(message.power);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseValidatorUpdate();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pubKey = PublicKey.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.power = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            pubKey: isSet(object.pubKey)
+                ? PublicKey.fromJSON(object.pubKey)
+                : undefined,
+            power: isSet(object.power) ? BigInt(object.power.toString()) : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.pubKey !== undefined &&
+            (obj.pubKey = message.pubKey
+                ? PublicKey.toJSON(message.pubKey)
+                : undefined);
+        message.power !== undefined &&
+            (obj.power = (message.power || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseValidatorUpdate();
+        message.pubKey =
+            object.pubKey !== undefined && object.pubKey !== null
+                ? PublicKey.fromPartial(object.pubKey)
+                : undefined;
+        message.power =
+            object.power !== undefined && object.power !== null
+                ? BigInt(object.power.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ValidatorUpdate.decode(message.value);
+    },
+    toProto(message) {
+        return ValidatorUpdate.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.ValidatorUpdate',
+            value: ValidatorUpdate.encode(message).finish(),
+        };
+    },
+};
+function createBaseVoteInfo() {
+    return {
+        validator: Validator.fromPartial({}),
+        signedLastBlock: false,
+    };
+}
+export const VoteInfo = {
+    typeUrl: '/tendermint.abci.VoteInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.validator !== undefined) {
+            Validator.encode(message.validator, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.signedLastBlock === true) {
+            writer.uint32(16).bool(message.signedLastBlock);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseVoteInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.validator = Validator.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.signedLastBlock = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            validator: isSet(object.validator)
+                ? Validator.fromJSON(object.validator)
+                : undefined,
+            signedLastBlock: isSet(object.signedLastBlock)
+                ? Boolean(object.signedLastBlock)
+                : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.validator !== undefined &&
+            (obj.validator = message.validator
+                ? Validator.toJSON(message.validator)
+                : undefined);
+        message.signedLastBlock !== undefined &&
+            (obj.signedLastBlock = message.signedLastBlock);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseVoteInfo();
+        message.validator =
+            object.validator !== undefined && object.validator !== null
+                ? Validator.fromPartial(object.validator)
+                : undefined;
+        message.signedLastBlock = object.signedLastBlock ?? false;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return VoteInfo.decode(message.value);
+    },
+    toProto(message) {
+        return VoteInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.VoteInfo',
+            value: VoteInfo.encode(message).finish(),
+        };
+    },
+};
+function createBaseEvidence() {
+    return {
+        type: 0,
+        validator: Validator.fromPartial({}),
+        height: BigInt(0),
+        time: Timestamp.fromPartial({}),
+        totalVotingPower: BigInt(0),
+    };
+}
+export const Evidence = {
+    typeUrl: '/tendermint.abci.Evidence',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== 0) {
+            writer.uint32(8).int32(message.type);
+        }
+        if (message.validator !== undefined) {
+            Validator.encode(message.validator, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.height !== BigInt(0)) {
+            writer.uint32(24).int64(message.height);
+        }
+        if (message.time !== undefined) {
+            Timestamp.encode(message.time, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.totalVotingPower !== BigInt(0)) {
+            writer.uint32(40).int64(message.totalVotingPower);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEvidence();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.int32();
+                    break;
+                case 2:
+                    message.validator = Validator.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.height = reader.int64();
+                    break;
+                case 4:
+                    message.time = Timestamp.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.totalVotingPower = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            type: isSet(object.type) ? evidenceTypeFromJSON(object.type) : -1,
+            validator: isSet(object.validator)
+                ? Validator.fromJSON(object.validator)
+                : undefined,
+            height: isSet(object.height)
+                ? BigInt(object.height.toString())
+                : BigInt(0),
+            time: isSet(object.time) ? fromJsonTimestamp(object.time) : undefined,
+            totalVotingPower: isSet(object.totalVotingPower)
+                ? BigInt(object.totalVotingPower.toString())
+                : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.type !== undefined && (obj.type = evidenceTypeToJSON(message.type));
+        message.validator !== undefined &&
+            (obj.validator = message.validator
+                ? Validator.toJSON(message.validator)
+                : undefined);
+        message.height !== undefined &&
+            (obj.height = (message.height || BigInt(0)).toString());
+        message.time !== undefined &&
+            (obj.time = fromTimestamp(message.time).toISOString());
+        message.totalVotingPower !== undefined &&
+            (obj.totalVotingPower = (message.totalVotingPower || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseEvidence();
+        message.type = object.type ?? 0;
+        message.validator =
+            object.validator !== undefined && object.validator !== null
+                ? Validator.fromPartial(object.validator)
+                : undefined;
+        message.height =
+            object.height !== undefined && object.height !== null
+                ? BigInt(object.height.toString())
+                : BigInt(0);
+        message.time =
+            object.time !== undefined && object.time !== null
+                ? Timestamp.fromPartial(object.time)
+                : undefined;
+        message.totalVotingPower =
+            object.totalVotingPower !== undefined && object.totalVotingPower !== null
+                ? BigInt(object.totalVotingPower.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return Evidence.decode(message.value);
+    },
+    toProto(message) {
+        return Evidence.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/tendermint.abci.Evidence',
+            value: Evidence.encode(message).finish(),
+        };
+    },
+};
+//# sourceMappingURL=types.js.map