@bandprotocol/bandchain.js/esm/codegen/band/base/node/v1/query.js

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { BinaryReader, BinaryWriter } from "../../../../binary";
function createBaseChainIDRequest() {
    return {};
}
export const ChainIDRequest = {
    typeUrl: "/band.base.node.v1.ChainIDRequest",
    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 = createBaseChainIDRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseChainIDRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseChainIDRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return ChainIDRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ChainIDRequest.decode(message.value);
    },
    toProto(message) {
        return ChainIDRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.node.v1.ChainIDRequest",
            value: ChainIDRequest.encode(message).finish()
        };
    }
};
function createBaseChainIDResponse() {
    return {
        chainId: ""
    };
}
export const ChainIDResponse = {
    typeUrl: "/band.base.node.v1.ChainIDResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.chainId !== "") {
            writer.uint32(10).string(message.chainId);
        }
        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 = createBaseChainIDResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.chainId = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseChainIDResponse();
        message.chainId = object.chainId ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseChainIDResponse();
        if (object.chain_id !== undefined && object.chain_id !== null) {
            message.chainId = object.chain_id;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.chain_id = message.chainId === "" ? undefined : message.chainId;
        return obj;
    },
    fromAminoMsg(object) {
        return ChainIDResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ChainIDResponse.decode(message.value);
    },
    toProto(message) {
        return ChainIDResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.node.v1.ChainIDResponse",
            value: ChainIDResponse.encode(message).finish()
        };
    }
};
function createBaseEVMValidatorsRequest() {
    return {};
}
export const EVMValidatorsRequest = {
    typeUrl: "/band.base.node.v1.EVMValidatorsRequest",
    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 = createBaseEVMValidatorsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseEVMValidatorsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseEVMValidatorsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return EVMValidatorsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return EVMValidatorsRequest.decode(message.value);
    },
    toProto(message) {
        return EVMValidatorsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.node.v1.EVMValidatorsRequest",
            value: EVMValidatorsRequest.encode(message).finish()
        };
    }
};
function createBaseEVMValidatorsResponse() {
    return {
        blockHeight: BigInt(0),
        validators: []
    };
}
export const EVMValidatorsResponse = {
    typeUrl: "/band.base.node.v1.EVMValidatorsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.blockHeight !== BigInt(0)) {
            writer.uint32(8).int64(message.blockHeight);
        }
        for (const v of message.validators) {
            ValidatorMinimal.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEVMValidatorsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.blockHeight = reader.int64();
                    break;
                case 2:
                    message.validators.push(ValidatorMinimal.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseEVMValidatorsResponse();
        message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? BigInt(object.blockHeight.toString()) : BigInt(0);
        message.validators = object.validators?.map(e => ValidatorMinimal.fromPartial(e)) || [];
        return message;
    },
    fromAmino(object) {
        const message = createBaseEVMValidatorsResponse();
        if (object.block_height !== undefined && object.block_height !== null) {
            message.blockHeight = BigInt(object.block_height);
        }
        message.validators = object.validators?.map(e => ValidatorMinimal.fromAmino(e)) || [];
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.block_height = message.blockHeight !== BigInt(0) ? message.blockHeight?.toString() : undefined;
        if (message.validators) {
            obj.validators = message.validators.map(e => e ? ValidatorMinimal.toAmino(e) : undefined);
        }
        else {
            obj.validators = message.validators;
        }
        return obj;
    },
    fromAminoMsg(object) {
        return EVMValidatorsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return EVMValidatorsResponse.decode(message.value);
    },
    toProto(message) {
        return EVMValidatorsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.node.v1.EVMValidatorsResponse",
            value: EVMValidatorsResponse.encode(message).finish()
        };
    }
};
function createBaseValidatorMinimal() {
    return {
        address: "",
        votingPower: BigInt(0)
    };
}
export const ValidatorMinimal = {
    typeUrl: "/band.base.node.v1.ValidatorMinimal",
    encode(message, writer = BinaryWriter.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.votingPower !== BigInt(0)) {
            writer.uint32(16).int64(message.votingPower);
        }
        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 = createBaseValidatorMinimal();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.address = reader.string();
                    break;
                case 2:
                    message.votingPower = reader.int64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseValidatorMinimal();
        message.address = object.address ?? "";
        message.votingPower = object.votingPower !== undefined && object.votingPower !== null ? BigInt(object.votingPower.toString()) : BigInt(0);
        return message;
    },
    fromAmino(object) {
        const message = createBaseValidatorMinimal();
        if (object.address !== undefined && object.address !== null) {
            message.address = object.address;
        }
        if (object.voting_power !== undefined && object.voting_power !== null) {
            message.votingPower = BigInt(object.voting_power);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.address = message.address === "" ? undefined : message.address;
        obj.voting_power = message.votingPower !== BigInt(0) ? message.votingPower?.toString() : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return ValidatorMinimal.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return ValidatorMinimal.decode(message.value);
    },
    toProto(message) {
        return ValidatorMinimal.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.base.node.v1.ValidatorMinimal",
            value: ValidatorMinimal.encode(message).finish()
        };
    }
};