@bandprotocol/bandchain.js/codegen/band/restake/v1beta1/types.d.ts

TypeScript library for Cosmos SDK and BandChain

import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
import { BinaryReader, BinaryWriter } from "../../../binary";
/** Vault is used for tracking the status of the vaults. */
export interface Vault {
    /** key is the key of the vault. */
    key: string;
    /** is_active is the status of the vault */
    isActive: boolean;
}
export interface VaultProtoMsg {
    typeUrl: "/band.restake.v1beta1.Vault";
    value: Uint8Array;
}
/** Vault is used for tracking the status of the vaults. */
export interface VaultAmino {
    /** key is the key of the vault. */
    key?: string;
    /** is_active is the status of the vault */
    is_active?: boolean;
}
export interface VaultAminoMsg {
    type: "/band.restake.v1beta1.Vault";
    value: VaultAmino;
}
/** Vault is used for tracking the status of the vaults. */
export interface VaultSDKType {
    key: string;
    is_active: boolean;
}
/** Lock is used to store lock information of each user on each vault. */
export interface Lock {
    /** staker_address is the owner's address of the staker. */
    stakerAddress: string;
    /** key is the key of the vault that this lock is locked to. */
    key: string;
    /** power is the number of locked power. */
    power: string;
}
export interface LockProtoMsg {
    typeUrl: "/band.restake.v1beta1.Lock";
    value: Uint8Array;
}
/** Lock is used to store lock information of each user on each vault. */
export interface LockAmino {
    /** staker_address is the owner's address of the staker. */
    staker_address?: string;
    /** key is the key of the vault that this lock is locked to. */
    key?: string;
    /** power is the number of locked power. */
    power?: string;
}
export interface LockAminoMsg {
    type: "/band.restake.v1beta1.Lock";
    value: LockAmino;
}
/** Lock is used to store lock information of each user on each vault. */
export interface LockSDKType {
    staker_address: string;
    key: string;
    power: string;
}
/** Stake is used to store staked coins of an address. */
export interface Stake {
    /** staker_address is the address that this stake belongs to. */
    stakerAddress: string;
    /** coins are the coins that the address has staked. */
    coins: Coin[];
}
export interface StakeProtoMsg {
    typeUrl: "/band.restake.v1beta1.Stake";
    value: Uint8Array;
}
/** Stake is used to store staked coins of an address. */
export interface StakeAmino {
    /** staker_address is the address that this stake belongs to. */
    staker_address?: string;
    /** coins are the coins that the address has staked. */
    coins: CoinAmino[];
}
export interface StakeAminoMsg {
    type: "/band.restake.v1beta1.Stake";
    value: StakeAmino;
}
/** Stake is used to store staked coins of an address. */
export interface StakeSDKType {
    staker_address: string;
    coins: CoinSDKType[];
}
/**
 * LockResponse is used as response of the query to show the power
 * that is locked by the vault for the user.
 */
export interface LockResponse {
    /** key is the key of the vault that this lock belongs to. */
    key: string;
    /** power is the number of locked power. */
    power: string;
}
export interface LockResponseProtoMsg {
    typeUrl: "/band.restake.v1beta1.LockResponse";
    value: Uint8Array;
}
/**
 * LockResponse is used as response of the query to show the power
 * that is locked by the vault for the user.
 */
export interface LockResponseAmino {
    /** key is the key of the vault that this lock belongs to. */
    key?: string;
    /** power is the number of locked power. */
    power?: string;
}
export interface LockResponseAminoMsg {
    type: "/band.restake.v1beta1.LockResponse";
    value: LockResponseAmino;
}
/**
 * LockResponse is used as response of the query to show the power
 * that is locked by the vault for the user.
 */
export interface LockResponseSDKType {
    key: string;
    power: string;
}
export declare const Vault: {
    typeUrl: string;
    encode(message: Vault, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Vault;
    fromPartial(object: Partial<Vault>): Vault;
    fromAmino(object: VaultAmino): Vault;
    toAmino(message: Vault): VaultAmino;
    fromAminoMsg(object: VaultAminoMsg): Vault;
    fromProtoMsg(message: VaultProtoMsg): Vault;
    toProto(message: Vault): Uint8Array;
    toProtoMsg(message: Vault): VaultProtoMsg;
};
export declare const Lock: {
    typeUrl: string;
    encode(message: Lock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Lock;
    fromPartial(object: Partial<Lock>): Lock;
    fromAmino(object: LockAmino): Lock;
    toAmino(message: Lock): LockAmino;
    fromAminoMsg(object: LockAminoMsg): Lock;
    fromProtoMsg(message: LockProtoMsg): Lock;
    toProto(message: Lock): Uint8Array;
    toProtoMsg(message: Lock): LockProtoMsg;
};
export declare const Stake: {
    typeUrl: string;
    encode(message: Stake, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Stake;
    fromPartial(object: Partial<Stake>): Stake;
    fromAmino(object: StakeAmino): Stake;
    toAmino(message: Stake): StakeAmino;
    fromAminoMsg(object: StakeAminoMsg): Stake;
    fromProtoMsg(message: StakeProtoMsg): Stake;
    toProto(message: Stake): Uint8Array;
    toProtoMsg(message: Stake): StakeProtoMsg;
};
export declare const LockResponse: {
    typeUrl: string;
    encode(message: LockResponse, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LockResponse;
    fromPartial(object: Partial<LockResponse>): LockResponse;
    fromAmino(object: LockResponseAmino): LockResponse;
    toAmino(message: LockResponse): LockResponseAmino;
    fromAminoMsg(object: LockResponseAminoMsg): LockResponse;
    fromProtoMsg(message: LockResponseProtoMsg): LockResponse;
    toProto(message: LockResponse): Uint8Array;
    toProtoMsg(message: LockResponse): LockResponseProtoMsg;
};