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

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { Result } from "../../../oracle/v1/oracle";
import { BinaryReader, BinaryWriter } from "../../../../binary";
import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
function createBaseProofRequest() {
    return {
        requestId: BigInt(0),
        height: BigInt(0)
    };
}
export const ProofRequest = {
    typeUrl: "/band.base.oracle.v1.ProofRequest",
    encode(message, writer = 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 BinaryReader ? input : new 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 ProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ProofRequest.decode(message.value);
    },
    toProto(message) {
        return ProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.ProofRequest",
            value: ProofRequest.encode(message).finish()
        };
    }
};
function createBaseProofResponse() {
    return {
        height: BigInt(0),
        result: SingleProofResult.fromPartial({})
    };
}
export const ProofResponse = {
    typeUrl: "/band.base.oracle.v1.ProofResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            SingleProofResult.encode(message.result, 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 = createBaseProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = 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 ? 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 = SingleProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? SingleProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return ProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ProofResponse.decode(message.value);
    },
    toProto(message) {
        return ProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.ProofResponse",
            value: ProofResponse.encode(message).finish()
        };
    }
};
function createBaseMultiProofRequest() {
    return {
        requestIds: []
    };
}
export const MultiProofRequest = {
    typeUrl: "/band.base.oracle.v1.MultiProofRequest",
    encode(message, writer = 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 BinaryReader ? input : new 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 MultiProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MultiProofRequest.decode(message.value);
    },
    toProto(message) {
        return MultiProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofRequest",
            value: MultiProofRequest.encode(message).finish()
        };
    }
};
function createBaseMultiProofResponse() {
    return {
        height: BigInt(0),
        result: MultiProofResult.fromPartial({})
    };
}
export const MultiProofResponse = {
    typeUrl: "/band.base.oracle.v1.MultiProofResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            MultiProofResult.encode(message.result, 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 = createBaseMultiProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = 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 ? 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 = MultiProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? MultiProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return MultiProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MultiProofResponse.decode(message.value);
    },
    toProto(message) {
        return MultiProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofResponse",
            value: MultiProofResponse.encode(message).finish()
        };
    }
};
function createBaseRequestCountProofRequest() {
    return {};
}
export const RequestCountProofRequest = {
    typeUrl: "/band.base.oracle.v1.RequestCountProofRequest",
    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 = 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 RequestCountProofRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RequestCountProofRequest.decode(message.value);
    },
    toProto(message) {
        return RequestCountProofRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.RequestCountProofRequest",
            value: RequestCountProofRequest.encode(message).finish()
        };
    }
};
function createBaseRequestCountProofResponse() {
    return {
        height: BigInt(0),
        result: CountProofResult.fromPartial({})
    };
}
export const RequestCountProofResponse = {
    typeUrl: "/band.base.oracle.v1.RequestCountProofResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.height !== BigInt(0)) {
            writer.uint32(8).int64(message.height);
        }
        if (message.result !== undefined) {
            CountProofResult.encode(message.result, 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 = createBaseRequestCountProofResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.height = reader.int64();
                    break;
                case 2:
                    message.result = 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 ? 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 = CountProofResult.fromAmino(object.result);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
        obj.result = message.result ? CountProofResult.toAmino(message.result) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return RequestCountProofResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return RequestCountProofResponse.decode(message.value);
    },
    toProto(message) {
        return RequestCountProofResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.RequestCountProofResponse",
            value: RequestCountProofResponse.encode(message).finish()
        };
    }
};
function createBaseSingleProofResult() {
    return {
        proof: SingleProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
export const SingleProofResult = {
    typeUrl: "/band.base.oracle.v1.SingleProofResult",
    encode(message, writer = BinaryWriter.create()) {
        if (message.proof !== undefined) {
            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 BinaryReader ? input : new 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 = 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 ? 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 = SingleProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = bytesFromBase64(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? SingleProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? base64FromBytes(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return SingleProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return SingleProofResult.decode(message.value);
    },
    toProto(message) {
        return SingleProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.SingleProofResult",
            value: SingleProofResult.encode(message).finish()
        };
    }
};
function createBaseMultiProofResult() {
    return {
        proof: MultiProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
export const MultiProofResult = {
    typeUrl: "/band.base.oracle.v1.MultiProofResult",
    encode(message, writer = BinaryWriter.create()) {
        if (message.proof !== undefined) {
            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 BinaryReader ? input : new 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 = 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 ? 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 = MultiProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = bytesFromBase64(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? MultiProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? base64FromBytes(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return MultiProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MultiProofResult.decode(message.value);
    },
    toProto(message) {
        return MultiProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProofResult",
            value: MultiProofResult.encode(message).finish()
        };
    }
};
function createBaseCountProofResult() {
    return {
        proof: CountProof.fromPartial({}),
        evmProofBytes: new Uint8Array()
    };
}
export const CountProofResult = {
    typeUrl: "/band.base.oracle.v1.CountProofResult",
    encode(message, writer = BinaryWriter.create()) {
        if (message.proof !== undefined) {
            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 BinaryReader ? input : new 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 = 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 ? 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 = CountProof.fromAmino(object.proof);
        }
        if (object.evm_proof_bytes !== undefined && object.evm_proof_bytes !== null) {
            message.evmProofBytes = bytesFromBase64(object.evm_proof_bytes);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.proof = message.proof ? CountProof.toAmino(message.proof) : undefined;
        obj.evm_proof_bytes = message.evmProofBytes ? base64FromBytes(message.evmProofBytes) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return CountProofResult.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return CountProofResult.decode(message.value);
    },
    toProto(message) {
        return CountProofResult.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.CountProofResult",
            value: CountProofResult.encode(message).finish()
        };
    }
};
function createBaseSingleProof() {
    return {
        blockHeight: BigInt(0),
        oracleDataProof: OracleDataProof.fromPartial({}),
        blockRelayProof: BlockRelayProof.fromPartial({})
    };
}
export const SingleProof = {
    typeUrl: "/band.base.oracle.v1.SingleProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        if (message.oracleDataProof !== undefined) {
            OracleDataProof.encode(message.oracleDataProof, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            BlockRelayProof.encode(message.blockRelayProof, 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 = createBaseSingleProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.oracleDataProof = OracleDataProof.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.blockRelayProof = 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 ? OracleDataProof.fromPartial(object.oracleDataProof) : undefined;
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? 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 = OracleDataProof.fromAmino(object.oracle_data_proof);
        }
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = 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 ? OracleDataProof.toAmino(message.oracleDataProof) : undefined;
        obj.block_relay_proof = message.blockRelayProof ? BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return SingleProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return SingleProof.decode(message.value);
    },
    toProto(message) {
        return SingleProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.SingleProof",
            value: SingleProof.encode(message).finish()
        };
    }
};
function createBaseMultiProof() {
    return {
        blockHeight: BigInt(0),
        oracleDataMultiProof: [],
        blockRelayProof: BlockRelayProof.fromPartial({})
    };
}
export const MultiProof = {
    typeUrl: "/band.base.oracle.v1.MultiProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        for (const v of message.oracleDataMultiProof) {
            OracleDataProof.encode(v, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            BlockRelayProof.encode(message.blockRelayProof, 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 = createBaseMultiProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.oracleDataMultiProof.push(OracleDataProof.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.blockRelayProof = 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 => OracleDataProof.fromPartial(e)) || [];
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? 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 => OracleDataProof.fromAmino(e)) || [];
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = 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 ? OracleDataProof.toAmino(e) : undefined);
        }
        else {
            obj.oracle_data_multi_proof = message.oracleDataMultiProof;
        }
        obj.block_relay_proof = message.blockRelayProof ? BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return MultiProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return MultiProof.decode(message.value);
    },
    toProto(message) {
        return MultiProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.MultiProof",
            value: MultiProof.encode(message).finish()
        };
    }
};
function createBaseCountProof() {
    return {
        blockHeight: BigInt(0),
        countProof: RequestsCountProof.fromPartial({}),
        blockRelayProof: BlockRelayProof.fromPartial({})
    };
}
export const CountProof = {
    typeUrl: "/band.base.oracle.v1.CountProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).uint64(message.blockHeight);
        }
        if (message.countProof !== undefined) {
            RequestsCountProof.encode(message.countProof, writer.uint32(18).fork()).ldelim();
        }
        if (message.blockRelayProof !== undefined) {
            BlockRelayProof.encode(message.blockRelayProof, 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 = createBaseCountProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.uint64();
                    break;
                case 2:
                    message.countProof = RequestsCountProof.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.blockRelayProof = 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 ? RequestsCountProof.fromPartial(object.countProof) : undefined;
        message.blockRelayProof = object.blockRelayProof !== undefined && object.blockRelayProof !== null ? 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 = RequestsCountProof.fromAmino(object.count_proof);
        }
        if (object.block_relay_proof !== undefined && object.block_relay_proof !== null) {
            message.blockRelayProof = 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 ? RequestsCountProof.toAmino(message.countProof) : undefined;
        obj.block_relay_proof = message.blockRelayProof ? BlockRelayProof.toAmino(message.blockRelayProof) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return CountProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return CountProof.decode(message.value);
    },
    toProto(message) {
        return CountProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.CountProof",
            value: CountProof.encode(message).finish()
        };
    }
};
function createBaseOracleDataProof() {
    return {
        result: Result.fromPartial({}),
        version: BigInt(0),
        merklePaths: []
    };
}
export const OracleDataProof = {
    typeUrl: "/band.base.oracle.v1.OracleDataProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.result !== undefined) {
            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) {
            IAVLMerklePath.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 = createBaseOracleDataProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.result = Result.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.version = reader.uint64();
                    break;
                case 3:
                    message.merklePaths.push(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 ? 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 => IAVLMerklePath.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseOracleDataProof();
        if (object.result !== undefined && object.result !== null) {
            message.result = Result.fromAmino(object.result);
        }
        if (object.version !== undefined && object.version !== null) {
            message.version = BigInt(object.version);
        }
        message.merklePaths = object.merkle_paths?.map(e => IAVLMerklePath.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.result = message.result ? 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 ? IAVLMerklePath.toAmino(e) : undefined);
        }
        else {
            obj.merkle_paths = message.merklePaths;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return OracleDataProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return OracleDataProof.decode(message.value);
    },
    toProto(message) {
        return OracleDataProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.OracleDataProof",
            value: OracleDataProof.encode(message).finish()
        };
    }
};
function createBaseIAVLMerklePath() {
    return {
        isDataOnRight: false,
        subtreeHeight: 0,
        subtreeSize: BigInt(0),
        subtreeVersion: BigInt(0),
        siblingHash: new Uint8Array()
    };
}
export const IAVLMerklePath = {
    typeUrl: "/band.base.oracle.v1.IAVLMerklePath",
    encode(message, writer = 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 BinaryReader ? input : new 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 = 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 ? base64FromBytes(message.siblingHash) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return IAVLMerklePath.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return IAVLMerklePath.decode(message.value);
    },
    toProto(message) {
        return IAVLMerklePath.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.IAVLMerklePath",
            value: IAVLMerklePath.encode(message).finish()
        };
    }
};
function createBaseBlockRelayProof() {
    return {
        multiStoreProof: MultiStoreProof.fromPartial({}),
        blockHeaderMerkleParts: BlockHeaderMerkleParts.fromPartial({}),
        commonEncodedVotePart: CommonEncodedVotePart.fromPartial({}),
        signatures: []
    };
}
export const BlockRelayProof = {
    typeUrl: "/band.base.oracle.v1.BlockRelayProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.multiStoreProof !== undefined) {
            MultiStoreProof.encode(message.multiStoreProof, writer.uint32(10).fork()).ldelim();
        }
        if (message.blockHeaderMerkleParts !== undefined) {
            BlockHeaderMerkleParts.encode(message.blockHeaderMerkleParts, writer.uint32(18).fork()).ldelim();
        }
        if (message.commonEncodedVotePart !== undefined) {
            CommonEncodedVotePart.encode(message.commonEncodedVotePart, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.signatures) {
            TMSignature.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 = createBaseBlockRelayProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.multiStoreProof = MultiStoreProof.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.blockHeaderMerkleParts = BlockHeaderMerkleParts.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.commonEncodedVotePart = CommonEncodedVotePart.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.signatures.push(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 ? MultiStoreProof.fromPartial(object.multiStoreProof) : undefined;
        message.blockHeaderMerkleParts = object.blockHeaderMerkleParts !== undefined && object.blockHeaderMerkleParts !== null ? BlockHeaderMerkleParts.fromPartial(object.blockHeaderMerkleParts) : undefined;
        message.commonEncodedVotePart = object.commonEncodedVotePart !== undefined && object.commonEncodedVotePart !== null ? CommonEncodedVotePart.fromPartial(object.commonEncodedVotePart) : undefined;
        message.signatures = object.signatures?.map(e => TMSignature.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseBlockRelayProof();
        if (object.multi_store_proof !== undefined && object.multi_store_proof !== null) {
            message.multiStoreProof = MultiStoreProof.fromAmino(object.multi_store_proof);
        }
        if (object.block_header_merkle_parts !== undefined && object.block_header_merkle_parts !== null) {
            message.blockHeaderMerkleParts = BlockHeaderMerkleParts.fromAmino(object.block_header_merkle_parts);
        }
        if (object.common_encoded_vote_part !== undefined && object.common_encoded_vote_part !== null) {
            message.commonEncodedVotePart = CommonEncodedVotePart.fromAmino(object.common_encoded_vote_part);
        }
        message.signatures = object.signatures?.map(e => TMSignature.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.multi_store_proof = message.multiStoreProof ? MultiStoreProof.toAmino(message.multiStoreProof) : undefined;
        obj.block_header_merkle_parts = message.blockHeaderMerkleParts ? BlockHeaderMerkleParts.toAmino(message.blockHeaderMerkleParts) : undefined;
        obj.common_encoded_vote_part = message.commonEncodedVotePart ? CommonEncodedVotePart.toAmino(message.commonEncodedVotePart) : undefined;
        if (message.signatures) {
            obj.signatures = message.signatures.map(e => e ? TMSignature.toAmino(e) : undefined);
        }
        else {
            obj.signatures = message.signatures;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return BlockRelayProof.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return BlockRelayProof.decode(message.value);
    },
    toProto(message) {
        return BlockRelayProof.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.oracle.v1.BlockRelayProof",
            value: BlockRelayProof.encode(message).finish()
        };
    }
};
function createBaseMultiStoreProof() {
    return {
        oracleIavlStateHash: new Uint8Array(),
        mintStoreMerkleHash: new Uint8Array(),
        paramsToRestakeStoresMerkleHash: new Uint8Array(),
        rollingseedToTransferStoresMerkleHash: new Uint8Array(),
        tssToUpgradeStoresMerkleHash: new Uint8Array(),
        authToIcahostStoresMerkleHash: new Uint8Array()
    };
}
export const MultiStoreProof = {
    typeUrl: "/band.base.oracle.v1.MultiStoreProof",
    encode(message, writer = BinaryWriter.create()) {
        if (message.oracleIavlStateHash.length !== 0) {
            writer.uint32(10).bytes(message.oracleIavlStateHash);
        }
        if (message.mintStoreMerkleHash.length !== 0) {
            writer.uint32(18).bytes(message.mintStoreMerkleHash);
        }
        if (message.paramsToRestakeStoresMerkleHash.length !== 0) {
            writer.uint32(26).bytes(message.paramsToRestakeStoresMerkleHash);
        }
        if (message.rollingseedToTransferStoresMerkleHash.length !== 0) {
            writer.uint32(34).bytes(message.rollingseedToTransferStoresMerkleHash);
        }
        if (message.tssToUpgradeStoresMerkleHash.length !== 0) {
            writer.uint32(42).bytes(message.tssToUpgradeStoresMerkleHash);
        }
        if (message.authToIcahostStoresMerkleHash.length !== 0) {
            writer.uint32(50).bytes(message.authToIcahostStoresMerkleHash);
        }
        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 = createBaseMultiStoreProof();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.oracleIavlStateHash = reader.bytes();
                    break;
                case 2:
                    message.mintStor