@bandprotocol/bandchain.js/esm/codegen/band/restake/v1beta1/query.js

TypeScript library for Cosmos SDK and BandChain

//@ts-nocheck
import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
import { Vault, LockResponse, Stake } from "./types";
import { Params } from "./genesis";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseQueryVaultsRequest() {
    return {
        pagination: undefined
    };
}
export const QueryVaultsRequest = {
    typeUrl: "/band.restake.v1beta1.QueryVaultsRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryVaultsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVaultsRequest();
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVaultsRequest();
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVaultsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVaultsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryVaultsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryVaultsRequest",
            value: QueryVaultsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryVaultsResponse() {
    return {
        vaults: [],
        pagination: undefined
    };
}
export const QueryVaultsResponse = {
    typeUrl: "/band.restake.v1beta1.QueryVaultsResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.vaults) {
            Vault.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, 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 = createBaseQueryVaultsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.vaults.push(Vault.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVaultsResponse();
        message.vaults = object.vaults?.map(e => Vault.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVaultsResponse();
        message.vaults = object.vaults?.map(e => Vault.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.vaults) {
            obj.vaults = message.vaults.map(e => e ? Vault.toAmino(e) : undefined);
        }
        else {
            obj.vaults = message.vaults;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVaultsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVaultsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryVaultsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryVaultsResponse",
            value: QueryVaultsResponse.encode(message).finish()
        };
    }
};
function createBaseQueryVaultRequest() {
    return {
        key: ""
    };
}
export const QueryVaultRequest = {
    typeUrl: "/band.restake.v1beta1.QueryVaultRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.key !== "") {
            writer.uint32(10).string(message.key);
        }
        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 = createBaseQueryVaultRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.key = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVaultRequest();
        message.key = object.key ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVaultRequest();
        if (object.key !== undefined && object.key !== null) {
            message.key = object.key;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.key = message.key === "" ? undefined : message.key;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVaultRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVaultRequest.decode(message.value);
    },
    toProto(message) {
        return QueryVaultRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryVaultRequest",
            value: QueryVaultRequest.encode(message).finish()
        };
    }
};
function createBaseQueryVaultResponse() {
    return {
        vault: Vault.fromPartial({})
    };
}
export const QueryVaultResponse = {
    typeUrl: "/band.restake.v1beta1.QueryVaultResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.vault !== undefined) {
            Vault.encode(message.vault, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryVaultResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.vault = Vault.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryVaultResponse();
        message.vault = object.vault !== undefined && object.vault !== null ? Vault.fromPartial(object.vault) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryVaultResponse();
        if (object.vault !== undefined && object.vault !== null) {
            message.vault = Vault.fromAmino(object.vault);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.vault = message.vault ? Vault.toAmino(message.vault) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryVaultResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryVaultResponse.decode(message.value);
    },
    toProto(message) {
        return QueryVaultResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryVaultResponse",
            value: QueryVaultResponse.encode(message).finish()
        };
    }
};
function createBaseQueryLocksRequest() {
    return {
        stakerAddress: "",
        pagination: undefined
    };
}
export const QueryLocksRequest = {
    typeUrl: "/band.restake.v1beta1.QueryLocksRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.stakerAddress !== "") {
            writer.uint32(10).string(message.stakerAddress);
        }
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, 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 = createBaseQueryLocksRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stakerAddress = reader.string();
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryLocksRequest();
        message.stakerAddress = object.stakerAddress ?? "";
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryLocksRequest();
        if (object.staker_address !== undefined && object.staker_address !== null) {
            message.stakerAddress = object.staker_address;
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.staker_address = message.stakerAddress === "" ? undefined : message.stakerAddress;
        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryLocksRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryLocksRequest.decode(message.value);
    },
    toProto(message) {
        return QueryLocksRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryLocksRequest",
            value: QueryLocksRequest.encode(message).finish()
        };
    }
};
function createBaseQueryLocksResponse() {
    return {
        locks: [],
        pagination: undefined
    };
}
export const QueryLocksResponse = {
    typeUrl: "/band.restake.v1beta1.QueryLocksResponse",
    encode(message, writer = BinaryWriter.create()) {
        for (const v of message.locks) {
            LockResponse.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, 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 = createBaseQueryLocksResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.locks.push(LockResponse.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryLocksResponse();
        message.locks = object.locks?.map(e => LockResponse.fromPartial(e)) || [];
        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryLocksResponse();
        message.locks = object.locks?.map(e => LockResponse.fromAmino(e)) || [];
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromAmino(object.pagination);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        if (message.locks) {
            obj.locks = message.locks.map(e => e ? LockResponse.toAmino(e) : undefined);
        }
        else {
            obj.locks = message.locks;
        }
        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryLocksResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryLocksResponse.decode(message.value);
    },
    toProto(message) {
        return QueryLocksResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryLocksResponse",
            value: QueryLocksResponse.encode(message).finish()
        };
    }
};
function createBaseQueryLockRequest() {
    return {
        stakerAddress: "",
        key: ""
    };
}
export const QueryLockRequest = {
    typeUrl: "/band.restake.v1beta1.QueryLockRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.stakerAddress !== "") {
            writer.uint32(10).string(message.stakerAddress);
        }
        if (message.key !== "") {
            writer.uint32(18).string(message.key);
        }
        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 = createBaseQueryLockRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stakerAddress = reader.string();
                    break;
                case 2:
                    message.key = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryLockRequest();
        message.stakerAddress = object.stakerAddress ?? "";
        message.key = object.key ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryLockRequest();
        if (object.staker_address !== undefined && object.staker_address !== null) {
            message.stakerAddress = object.staker_address;
        }
        if (object.key !== undefined && object.key !== null) {
            message.key = object.key;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.staker_address = message.stakerAddress === "" ? undefined : message.stakerAddress;
        obj.key = message.key === "" ? undefined : message.key;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryLockRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryLockRequest.decode(message.value);
    },
    toProto(message) {
        return QueryLockRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryLockRequest",
            value: QueryLockRequest.encode(message).finish()
        };
    }
};
function createBaseQueryLockResponse() {
    return {
        lock: LockResponse.fromPartial({})
    };
}
export const QueryLockResponse = {
    typeUrl: "/band.restake.v1beta1.QueryLockResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.lock !== undefined) {
            LockResponse.encode(message.lock, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryLockResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.lock = LockResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryLockResponse();
        message.lock = object.lock !== undefined && object.lock !== null ? LockResponse.fromPartial(object.lock) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryLockResponse();
        if (object.lock !== undefined && object.lock !== null) {
            message.lock = LockResponse.fromAmino(object.lock);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.lock = message.lock ? LockResponse.toAmino(message.lock) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryLockResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryLockResponse.decode(message.value);
    },
    toProto(message) {
        return QueryLockResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryLockResponse",
            value: QueryLockResponse.encode(message).finish()
        };
    }
};
function createBaseQueryStakeRequest() {
    return {
        stakerAddress: ""
    };
}
export const QueryStakeRequest = {
    typeUrl: "/band.restake.v1beta1.QueryStakeRequest",
    encode(message, writer = BinaryWriter.create()) {
        if (message.stakerAddress !== "") {
            writer.uint32(10).string(message.stakerAddress);
        }
        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 = createBaseQueryStakeRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stakerAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryStakeRequest();
        message.stakerAddress = object.stakerAddress ?? "";
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryStakeRequest();
        if (object.staker_address !== undefined && object.staker_address !== null) {
            message.stakerAddress = object.staker_address;
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.staker_address = message.stakerAddress === "" ? undefined : message.stakerAddress;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryStakeRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryStakeRequest.decode(message.value);
    },
    toProto(message) {
        return QueryStakeRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryStakeRequest",
            value: QueryStakeRequest.encode(message).finish()
        };
    }
};
function createBaseQueryStakeResponse() {
    return {
        stake: Stake.fromPartial({})
    };
}
export const QueryStakeResponse = {
    typeUrl: "/band.restake.v1beta1.QueryStakeResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.stake !== undefined) {
            Stake.encode(message.stake, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryStakeResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stake = Stake.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryStakeResponse();
        message.stake = object.stake !== undefined && object.stake !== null ? Stake.fromPartial(object.stake) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryStakeResponse();
        if (object.stake !== undefined && object.stake !== null) {
            message.stake = Stake.fromAmino(object.stake);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.stake = message.stake ? Stake.toAmino(message.stake) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryStakeResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryStakeResponse.decode(message.value);
    },
    toProto(message) {
        return QueryStakeResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryStakeResponse",
            value: QueryStakeResponse.encode(message).finish()
        };
    }
};
function createBaseQueryParamsRequest() {
    return {};
}
export const QueryParamsRequest = {
    typeUrl: "/band.restake.v1beta1.QueryParamsRequest",
    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 = createBaseQueryParamsRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    fromAmino(_) {
        const message = createBaseQueryParamsRequest();
        return message;
    },
    toAmino(_) {
        const obj = {};
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsRequest.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsRequest.decode(message.value);
    },
    toProto(message) {
        return QueryParamsRequest.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryParamsRequest",
            value: QueryParamsRequest.encode(message).finish()
        };
    }
};
function createBaseQueryParamsResponse() {
    return {
        params: Params.fromPartial({})
    };
}
export const QueryParamsResponse = {
    typeUrl: "/band.restake.v1beta1.QueryParamsResponse",
    encode(message, writer = BinaryWriter.create()) {
        if (message.params !== undefined) {
            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.params = Params.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseQueryParamsResponse();
        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
        return message;
    },
    fromAmino(object) {
        const message = createBaseQueryParamsResponse();
        if (object.params !== undefined && object.params !== null) {
            message.params = Params.fromAmino(object.params);
        }
        return message;
    },
    toAmino(message) {
        const obj = {};
        obj.params = message.params ? Params.toAmino(message.params) : undefined;
        return obj;
    },
    fromAminoMsg(object) {
        return QueryParamsResponse.fromAmino(object.value);
    },
    fromProtoMsg(message) {
        return QueryParamsResponse.decode(message.value);
    },
    toProto(message) {
        return QueryParamsResponse.encode(message).finish();
    },
    toProtoMsg(message) {
        return {
            typeUrl: "/band.restake.v1beta1.QueryParamsResponse",
            value: QueryParamsResponse.encode(message).finish()
        };
    }
};