@bandprotocol/bandchain.js/codegen/band/base/oracle/v1/proof.js

TypeScript library for Cosmos SDK and BandChain

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequestsCountProof = exports.TMSignature = exports.CommonEncodedVotePart = exports.BlockHeaderMerkleParts = exports.MultiStoreProof = exports.BlockRelayProof = exports.IAVLMerklePath = exports.OracleDataProof = exports.CountProof = exports.MultiProof = exports.SingleProof = exports.CountProofResult = exports.MultiProofResult = exports.SingleProofResult = exports.RequestCountProofResponse = exports.RequestCountProofRequest = exports.MultiProofResponse = exports.MultiProofRequest = exports.ProofResponse = exports.ProofRequest = void 0;
//@ts-nocheck
const oracle_1 = require("../../../oracle/v1/oracle");
const binary_1 = require("../../../../binary");
const helpers_1 = require("../../../../helpers");
function createBaseProofRequest() {
    return {
        requestId: BigInt(0),
        height: BigInt(0)
    };
}
exports.ProofRequest = {
    typeUrl: "/band.base.oracle.v1.ProofRequest",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.requestId !== BigInt(0)) {
            writer.uint32(8).uint64(message.requestId);
        }
        if (message.height !== BigInt(0)) {
            writer.uint32(16).int64(message.height);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseProofRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestId = reader.uint64();
                    break;
                case 2:
                    message.height = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseProofRequest();
        message.requestId = object.requestId !== undefined && object.requestId !== null ? BigInt(object.requestId.toString()) : BigInt(0);
        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseProofRequest();
        if (object.request_id !== undefined && object.request_id !== null) {
            message.requestId = BigInt(object.request_id);
        }
        if (object.height !== undefined && object.height !== null) {
            message.height = BigInt(object.height);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.request_id = message.requestId !== BigInt(0) ? message.requestId?.toString() : undefined;
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.ProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.ProofRequest.decode(message.value);
    },
    toProto(message) {
        return exports.ProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.ProofRequest",
            value: exports.ProofRequest.encode(message).finish()
        };
    }
};
function createBaseProofResponse() {
    return {
        height: BigInt(0),
        result: exports.SingleProofResult.fromPartial({})
    };
}
exports.ProofResponse = {
    typeUrl: "/band.base.oracle.v1.ProofResponse",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            exports.SingleProofResult.encode(message.result, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = exports.SingleProofResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseProofResponse();
        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
        message.result = object.result !== undefined && object.result !== null ? exports.SingleProofResult.fromPartial(object.result) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseProofResponse();
        if (object.height !== undefined && object.height !== null) {
            message.height = BigInt(object.height);
        }
        if (object.result !== undefined && object.result !== null) {
            message.result = exports.SingleProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? exports.SingleProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.ProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.ProofResponse.decode(message.value);
    },
    toProto(message) {
        return exports.ProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.ProofResponse",
            value: exports.ProofResponse.encode(message).finish()
        };
    }
};
function createBaseMultiProofRequest() {
    return {
        requestIds: []
    };
}
exports.MultiProofRequest = {
    typeUrl: "/band.base.oracle.v1.MultiProofRequest",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        writer.uint32(10).fork();
        for (const v of message.requestIds) {
            writer.uint64(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMultiProofRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.requestIds.push(reader.uint64());
                        }
                    }
                    else {
                        message.requestIds.push(reader.uint64());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMultiProofRequest();
        message.requestIds = object.requestIds?.map(e => BigInt(e.toString())) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseMultiProofRequest();
        message.requestIds = object.request_ids?.map(e => BigInt(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.requestIds) {
            obj.request_ids = message.requestIds.map(e => e.toString());
        }
        else {
            obj.request_ids = message.requestIds;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MultiProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MultiProofRequest.decode(message.value);
    },
    toProto(message) {
        return exports.MultiProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofRequest",
            value: exports.MultiProofRequest.encode(message).finish()
        };
    }
};
function createBaseMultiProofResponse() {
    return {
        height: BigInt(0),
        result: exports.MultiProofResult.fromPartial({})
    };
}
exports.MultiProofResponse = {
    typeUrl: "/band.base.oracle.v1.MultiProofResponse",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            exports.MultiProofResult.encode(message.result, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMultiProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = exports.MultiProofResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMultiProofResponse();
        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
        message.result = object.result !== undefined && object.result !== null ? exports.MultiProofResult.fromPartial(object.result) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseMultiProofResponse();
        if (object.height !== undefined && object.height !== null) {
            message.height = BigInt(object.height);
        }
        if (object.result !== undefined && object.result !== null) {
            message.result = exports.MultiProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? exports.MultiProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MultiProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MultiProofResponse.decode(message.value);
    },
    toProto(message) {
        return exports.MultiProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofResponse",
            value: exports.MultiProofResponse.encode(message).finish()
        };
    }
};
function createBaseRequestCountProofRequest() {
    return {};
}
exports.RequestCountProofRequest = {
    typeUrl: "/band.base.oracle.v1.RequestCountProofRequest",
    encode(_, writer = binary_1.BinaryWriter.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseRequestCountProofRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseRequestCountProofRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseRequestCountProofRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return exports.RequestCountProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.RequestCountProofRequest.decode(message.value);
    },
    toProto(message) {
        return exports.RequestCountProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.RequestCountProofRequest",
            value: exports.RequestCountProofRequest.encode(message).finish()
        };
    }
};
function createBaseRequestCountProofResponse() {
    return {
        height: BigInt(0),
        result: exports.CountProofResult.fromPartial({})
    };
}
exports.RequestCountProofResponse = {
    typeUrl: "/band.base.oracle.v1.RequestCountProofResponse",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            exports.CountProofResult.encode(message.result, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseRequestCountProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = exports.CountProofResult.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseRequestCountProofResponse();
        message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
        message.result = object.result !== undefined && object.result !== null ? exports.CountProofResult.fromPartial(object.result) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseRequestCountProofResponse();
        if (object.height !== undefined && object.height !== null) {
            message.height = BigInt(object.height);
        }
        if (object.result !== undefined && object.result !== null) {
            message.result = exports.CountProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? exports.CountProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.RequestCountProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.RequestCountProofResponse.decode(message.value);
    },
    toProto(message) {
        return exports.RequestCountProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.RequestCountProofResponse",
            value: exports.RequestCountProofResponse.encode(message).finish()
        };
    }
};
function createBaseSingleProofResult() {
    return {
        proof: exports.SingleProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
exports.SingleProofResult = {
    typeUrl: "/band.base.oracle.v1.SingleProofResult",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.proof !== undefined) {
            exports.SingleProof.encode(message.proof, writer.uint32(10).fork()).ldelim();
        }
        if (message.evmProofBytes.length !== 0) {
            writer.uint32(18).bytes(message.evmProofBytes);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSingleProofResult();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.proof = exports.SingleProof.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.evmProofBytes = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseSingleProofResult();
        message.proof = object.proof !== undefined && object.proof !== null ? exports.SingleProof.fromPartial(object.proof) : undefined;
        message.evmProofBytes = object.evmProofBytes ?? new Uint8Array();
        return message;
    },
    fromAmino(object) {
        const message = createBaseSingleProofResult();
        if (object.proof !== undefined && object.proof !== null) {
            message.proof = exports.SingleProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = (0, helpers_1.bytesFromBase64)(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? exports.SingleProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? (0, helpers_1.base64FromBytes)(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.SingleProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.SingleProofResult.decode(message.value);
    },
    toProto(message) {
        return exports.SingleProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.SingleProofResult",
            value: exports.SingleProofResult.encode(message).finish()
        };
    }
};
function createBaseMultiProofResult() {
    return {
        proof: exports.MultiProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
exports.MultiProofResult = {
    typeUrl: "/band.base.oracle.v1.MultiProofResult",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.proof !== undefined) {
            exports.MultiProof.encode(message.proof, writer.uint32(10).fork()).ldelim();
        }
        if (message.evmProofBytes.length !== 0) {
            writer.uint32(18).bytes(message.evmProofBytes);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMultiProofResult();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.proof = exports.MultiProof.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.evmProofBytes = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMultiProofResult();
        message.proof = object.proof !== undefined && object.proof !== null ? exports.MultiProof.fromPartial(object.proof) : undefined;
        message.evmProofBytes = object.evmProofBytes ?? new Uint8Array();
        return message;
    },
    fromAmino(object) {
        const message = createBaseMultiProofResult();
        if (object.proof !== undefined && object.proof !== null) {
            message.proof = exports.MultiProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = (0, helpers_1.bytesFromBase64)(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? exports.MultiProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? (0, helpers_1.base64FromBytes)(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MultiProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MultiProofResult.decode(message.value);
    },
    toProto(message) {
        return exports.MultiProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofResult",
            value: exports.MultiProofResult.encode(message).finish()
        };
    }
};
function createBaseCountProofResult() {
    return {
        proof: exports.CountProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
exports.CountProofResult = {
    typeUrl: "/band.base.oracle.v1.CountProofResult",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.proof !== undefined) {
            exports.CountProof.encode(message.proof, writer.uint32(10).fork()).ldelim();
        }
        if (message.evmProofBytes.length !== 0) {
            writer.uint32(18).bytes(message.evmProofBytes);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCountProofResult();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.proof = exports.CountProof.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.evmProofBytes = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCountProofResult();
        message.proof = object.proof !== undefined && object.proof !== null ? exports.CountProof.fromPartial(object.proof) : undefined;
        message.evmProofBytes = object.evmProofBytes ?? new Uint8Array();
        return message;
    },
    fromAmino(object) {
        const message = createBaseCountProofResult();
        if (object.proof !== undefined && object.proof !== null) {
            message.proof = exports.CountProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = (0, helpers_1.bytesFromBase64)(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? exports.CountProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? (0, helpers_1.base64FromBytes)(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.CountProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.CountProofResult.decode(message.value);
    },
    toProto(message) {
        return exports.CountProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.CountProofResult",
            value: exports.CountProofResult.encode(message).finish()
        };
    }
};
function createBaseSingleProof() {
    return {
        blockHeight: BigInt(0),
        oracleDataProof: exports.OracleDataProof.fromPartial({}),
        blockRelayProof: exports.BlockRelayProof.fromPartial({})
    };
}
exports.SingleProof = {
    typeUrl: "/band.base.oracle.v1.SingleProof",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        if (message.oracleDataProof !== undefined) {
            exports.OracleDataProof.encode(message.oracleDataProof, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            exports.BlockRelayProof.encode(message.blockRelayProof, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSingleProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.oracleDataProof = exports.OracleDataProof.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.blockRelayProof = exports.BlockRelayProof.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseSingleProof();
        message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
        message.oracleDataProof = object.oracleDataProof !== undefined && object.oracleDataProof !== null ? exports.OracleDataProof.fromPartial(object.oracleDataProof) : undefined;
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? exports.BlockRelayProof.fromPartial(object.blockRelayProof) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseSingleProof();
        if (object.block_height !== undefined && object.block_height !== null) {
            message.blockHeight = BigInt(object.block_height);
        }
        if (object.oracle_data_proof !== undefined && object.oracle_data_proof !== null) {
            message.oracleDataProof = exports.OracleDataProof.fromAmino(object.oracle_data_proof);
        }
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = exports.BlockRelayProof.fromAmino(object.block_relay_proof);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
        obj.oracle_data_proof = message.oracleDataProof ? exports.OracleDataProof.toAmino(message.oracleDataProof) : undefined;
        obj.block_relay_proof = message.blockRelayProof ? exports.BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.SingleProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.SingleProof.decode(message.value);
    },
    toProto(message) {
        return exports.SingleProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.SingleProof",
            value: exports.SingleProof.encode(message).finish()
        };
    }
};
function createBaseMultiProof() {
    return {
        blockHeight: BigInt(0),
        oracleDataMultiProof: [],
        blockRelayProof: exports.BlockRelayProof.fromPartial({})
    };
}
exports.MultiProof = {
    typeUrl: "/band.base.oracle.v1.MultiProof",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        for (const v of message.oracleDataMultiProof) {
            exports.OracleDataProof.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            exports.BlockRelayProof.encode(message.blockRelayProof, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMultiProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.oracleDataMultiProof.push(exports.OracleDataProof.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.blockRelayProof = exports.BlockRelayProof.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseMultiProof();
        message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
        message.oracleDataMultiProof = object.oracleDataMultiProof?.map(e => exports.OracleDataProof.fromPartial(e)) || [];
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? exports.BlockRelayProof.fromPartial(object.blockRelayProof) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseMultiProof();
        if (object.block_height !== undefined && object.block_height !== null) {
            message.blockHeight = BigInt(object.block_height);
        }
        message.oracleDataMultiProof = object.oracle_data_multi_proof?.map(e => exports.OracleDataProof.fromAmino(e)) || [];
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = exports.BlockRelayProof.fromAmino(object.block_relay_proof);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
        if (message.oracleDataMultiProof) {
            obj.oracle_data_multi_proof = message.oracleDataMultiProof.map(e => e ? exports.OracleDataProof.toAmino(e) : undefined);
        }
        else {
            obj.oracle_data_multi_proof = message.oracleDataMultiProof;
        }
        obj.block_relay_proof = message.blockRelayProof ? exports.BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.MultiProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.MultiProof.decode(message.value);
    },
    toProto(message) {
        return exports.MultiProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProof",
            value: exports.MultiProof.encode(message).finish()
        };
    }
};
function createBaseCountProof() {
    return {
        blockHeight: BigInt(0),
        countProof: exports.RequestsCountProof.fromPartial({}),
        blockRelayProof: exports.BlockRelayProof.fromPartial({})
    };
}
exports.CountProof = {
    typeUrl: "/band.base.oracle.v1.CountProof",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        if (message.countProof !== undefined) {
            exports.RequestsCountProof.encode(message.countProof, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            exports.BlockRelayProof.encode(message.blockRelayProof, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCountProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.countProof = exports.RequestsCountProof.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.blockRelayProof = exports.BlockRelayProof.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCountProof();
        message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
        message.countProof = object.countProof !== undefined && object.countProof !== null ? exports.RequestsCountProof.fromPartial(object.countProof) : undefined;
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? exports.BlockRelayProof.fromPartial(object.blockRelayProof) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseCountProof();
        if (object.block_height !== undefined && object.block_height !== null) {
            message.blockHeight = BigInt(object.block_height);
        }
        if (object.count_proof !== undefined && object.count_proof !== null) {
            message.countProof = exports.RequestsCountProof.fromAmino(object.count_proof);
        }
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = exports.BlockRelayProof.fromAmino(object.block_relay_proof);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
        obj.count_proof = message.countProof ? exports.RequestsCountProof.toAmino(message.countProof) : undefined;
        obj.block_relay_proof = message.blockRelayProof ? exports.BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.CountProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.CountProof.decode(message.value);
    },
    toProto(message) {
        return exports.CountProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.CountProof",
            value: exports.CountProof.encode(message).finish()
        };
    }
};
function createBaseOracleDataProof() {
    return {
        result: oracle_1.Result.fromPartial({}),
        version: BigInt(0),
        merklePaths: []
    };
}
exports.OracleDataProof = {
    typeUrl: "/band.base.oracle.v1.OracleDataProof",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.result !== undefined) {
            oracle_1.Result.encode(message.result, writer.uint32(10).fork()).ldelim();
        }
        if (message.version !== BigInt(0)) {
            writer.uint32(16).uint64(message.version);
        }
        for (const v of message.merklePaths) {
            exports.IAVLMerklePath.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseOracleDataProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.result = oracle_1.Result.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.version = reader.uint64();
                    break;
                case 3:
                    message.merklePaths.push(exports.IAVLMerklePath.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseOracleDataProof();
        message.result = object.result !== undefined && object.result !== null ? oracle_1.Result.fromPartial(object.result) : undefined;
        message.version = object.version !== undefined && object.version !== null ? BigInt(object.version.toString()) : BigInt(0);
        message.merklePaths = object.merklePaths?.map(e => exports.IAVLMerklePath.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseOracleDataProof();
        if (object.result !== undefined && object.result !== null) {
            message.result = oracle_1.Result.fromAmino(object.result);
        }
        if (object.version !== undefined && object.version !== null) {
            message.version = BigInt(object.version);
        }
        message.merklePaths = object.merkle_paths?.map(e => exports.IAVLMerklePath.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.result = message.result ? oracle_1.Result.toAmino(message.result) : undefined;
        obj.version = message.version !== BigInt(0) ? message.version?.toString() : undefined;
        if (message.merklePaths) {
            obj.merkle_paths = message.merklePaths.map(e => e ? exports.IAVLMerklePath.toAmino(e) : undefined);
        }
        else {
            obj.merkle_paths = message.merklePaths;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.OracleDataProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.OracleDataProof.decode(message.value);
    },
    toProto(message) {
        return exports.OracleDataProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.OracleDataProof",
            value: exports.OracleDataProof.encode(message).finish()
        };
    }
};
function createBaseIAVLMerklePath() {
    return {
        isDataOnRight: false,
        subtreeHeight: 0,
        subtreeSize: BigInt(0),
        subtreeVersion: BigInt(0),
        siblingHash: new Uint8Array()
    };
}
exports.IAVLMerklePath = {
    typeUrl: "/band.base.oracle.v1.IAVLMerklePath",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.isDataOnRight === true) {
            writer.uint32(8).bool(message.isDataOnRight);
        }
        if (message.subtreeHeight !== 0) {
            writer.uint32(16).uint32(message.subtreeHeight);
        }
        if (message.subtreeSize !== BigInt(0)) {
            writer.uint32(24).uint64(message.subtreeSize);
        }
        if (message.subtreeVersion !== BigInt(0)) {
            writer.uint32(32).uint64(message.subtreeVersion);
        }
        if (message.siblingHash.length !== 0) {
            writer.uint32(42).bytes(message.siblingHash);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseIAVLMerklePath();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isDataOnRight = reader.bool();
                    break;
                case 2:
                    message.subtreeHeight = reader.uint32();
                    break;
                case 3:
                    message.subtreeSize = reader.uint64();
                    break;
                case 4:
                    message.subtreeVersion = reader.uint64();
                    break;
                case 5:
                    message.siblingHash = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseIAVLMerklePath();
        message.isDataOnRight = object.isDataOnRight ?? false;
        message.subtreeHeight = object.subtreeHeight ?? 0;
        message.subtreeSize = object.subtreeSize !== undefined && object.subtreeSize !== null ? BigInt(object.subtreeSize.toString()) : BigInt(0);
        message.subtreeVersion = object.subtreeVersion !== undefined && object.subtreeVersion !== null ? BigInt(object.subtreeVersion.toString()) : BigInt(0);
        message.siblingHash = object.siblingHash ?? new Uint8Array();
        return message;
    },
    fromAmino(object) {
        const message = createBaseIAVLMerklePath();
        if (object.is_data_on_right !== undefined && object.is_data_on_right !== null) {
            message.isDataOnRight = object.is_data_on_right;
        }
        if (object.subtree_height !== undefined && object.subtree_height !== null) {
            message.subtreeHeight = object.subtree_height;
        }
        if (object.subtree_size !== undefined && object.subtree_size !== null) {
            message.subtreeSize = BigInt(object.subtree_size);
        }
        if (object.subtree_version !== undefined && object.subtree_version !== null) {
            message.subtreeVersion = BigInt(object.subtree_version);
        }
        if (object.sibling_hash !== undefined && object.sibling_hash !== null) {
            message.siblingHash = (0, helpers_1.bytesFromBase64)(object.sibling_hash);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.is_data_on_right = message.isDataOnRight === false ? undefined : message.isDataOnRight;
        obj.subtree_height = message.subtreeHeight === 0 ? undefined : message.subtreeHeight;
        obj.subtree_size = message.subtreeSize !== BigInt(0) ? message.subtreeSize?.toString() : undefined;
        obj.subtree_version = message.subtreeVersion !== BigInt(0) ? message.subtreeVersion?.toString() : undefined;
        obj.sibling_hash = message.siblingHash ? (0, helpers_1.base64FromBytes)(message.siblingHash) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return exports.IAVLMerklePath.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return exports.IAVLMerklePath.decode(message.value);
    },
    toProto(message) {
        return exports.IAVLMerklePath.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.IAVLMerklePath",
            value: exports.IAVLMerklePath.encode(message).finish()
        };
    }
};
function createBaseBlockRelayProof() {
    return {
        multiStoreProof: exports.MultiStoreProof.fromPartial({}),
        blockHeaderMerkleParts: exports.BlockHeaderMerkleParts.fromPartial({}),
        commonEncodedVotePart: exports.CommonEncodedVotePart.fromPartial({}),
        signatures: []
    };
}
exports.BlockRelayProof = {
    typeUrl: "/band.base.oracle.v1.BlockRelayProof",
    encode(message, writer = binary_1.BinaryWriter.create()) {
        if (message.multiStoreProof !== undefined) {
            exports.MultiStoreProof.encode(message.multiStoreProof, writer.uint32(10).fork()).ldelim();
        }
        if (message.blockHeaderMerkleParts !== undefined) {
            exports.BlockHeaderMerkleParts.encode(message.blockHeaderMerkleParts, writer.uint32(18).fork()).ldelim();
        }
        if (message.commonEncodedVotePart !== undefined) {
            exports.CommonEncodedVotePart.encode(message.commonEncodedVotePart, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.signatures) {
            exports.TMSignature.encode(v, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseBlockRelayProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.multiStoreProof = exports.MultiStoreProof.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.blockHeaderMerkleParts = exports.BlockHeaderMerkleParts.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.commonEncodedVotePart = exports.CommonEncodedVotePart.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.signatures.push(exports.TMSignature.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseBlockRelayProof();
        message.multiStoreProof = object.multiStoreProof !== undefined && object.multiStoreProof !== null ? exports.MultiStoreProof.fromPartial(object.multiStoreProof) : undefined;
        message.blockHeaderMerkleParts = object.blockHeaderMerkleParts !== undefined && object.blockHeaderMerkleParts !== null ? exports.BlockHeaderMerkleParts.fromPartial(object.blockHeaderMerkleParts) : undefined;
        message.commonEncodedVotePart = object.commonEncodedVotePart !== undefined && object.commonEncodedVotePart !== null ? exports.CommonEncodedVotePart.fromPartial(object.commonEncodedVotePart) : undefined;
        message.signatures = object.signatures?.map(e => exports.TMSignature.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseBlockRelayProof();
        if (object.multi_store_proof !== undefined && object.multi_store_proof !== null) {
            message.multiStoreProof = exports.MultiStoreProof.fromAmino(object.multi_store_proof);
        }
        if (object.block_header_merkle_parts !== undefined && object.block_header_merkle_parts !== null) {
            message.blockHeaderMerkleParts = exports.BlockHeaderMerkleParts.fromAmino(object.block_header_merkle_parts);
        }
        if (object.common_encoded_vote_part !== undefined && object.common_encoded_vote_part !== null) {
            message.commonEncodedVotePart = exports.CommonEncodedVotePart.fromAmino(object.common_encoded_vote_part);
        }
        message.signatures = object.signatures?.map(e => exports.TMSignature.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.multi_store_proof = message.multiStoreProof ? exports.MultiStoreProof.toAmino(message.multiStoreProof) : undefined;
        obj.block_header_merkle_parts = message.blockHeaderMerkleParts ? exports.BlockHeaderMerkleParts.toAmino(message.blockHeaderMerkleParts) : undefined;
        obj.common_encoded_vote_part = message.commonEncodedVotePart ? exports.CommonEncodedVotePart.toAmino(message.commonEncodedVotePart) : undefined;
        if (message.signatures) {
            obj.signatures = message.signatures.map(e => e ? exports.TMSignature.toAmino(e) : undefined);
        }
        else {
            obj.signatures = message.signatures;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return exports.BlockRelayProof.fromAmino(object.value);
    },