@zebec-network/zebec-stake-sdk/dist/service.d.ts

An SDK for zebec network stake solana program

import { Address, AnchorProvider, BN, Program, Provider } from "@coral-xyz/anchor";
import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
import { TransactionPayload } from "@zebec-network/solana-common";
import { ZebecStakeIdlV1 } from "./artifacts";
import { ReadonlyProvider } from "./providers";
type ProgramCreateFunction = (provider: ReadonlyProvider | AnchorProvider) => Program<ZebecStakeIdlV1>;
/**
 * StakeServiceBuilder is a builder class for creating a StakeService instance.
 * It allows you to set the network, provider, and program to use.
 */
export declare class StakeServiceBuilder {
    private _program;
    private _provider;
    private _network;
    /**
     *
     * @param network The network to use. If not set, a default network: 'mainnet-beta' will be used.
     * @returns
     */
    setNetwork(network?: "mainnet-beta" | "devnet"): StakeServiceBuilder;
    /**
     * Set the provider to use. If not set, a default provider will be created.
     * @param provider The provider to use. If not set, a default provider: 'ReadonlyProvider' will be created.
     * @returns The StakeServiceBuilder instance.
     */
    setProvider(provider?: ReadonlyProvider | AnchorProvider): StakeServiceBuilder;
    /**
     *
     * @param provider The provider to compare with.
     */
    private validateProviderNetwork;
    /**
     * Set the program to use. If not set, a default program will be created.
     * @param program The program to use. If not set, a default program will be created.
     * @returns The StakeServiceBuilder instance.
     */
    setProgram(createProgram?: ProgramCreateFunction): StakeServiceBuilder;
    build(): StakeService;
}
export declare class StakeService {
    readonly provider: Provider;
    readonly program: Program<ZebecStakeIdlV1>;
    readonly network: "mainnet-beta" | "devnet";
    constructor(provider: Provider, program: Program<ZebecStakeIdlV1>, network: "mainnet-beta" | "devnet");
    private _createPayload;
    getInitLockupInstruction(creator: PublicKey, lockup: PublicKey, stakeToken: PublicKey, rewardToken: PublicKey, rewardVault: PublicKey, stakeVault: PublicKey, data: InitLockupInstructionData): Promise<TransactionInstruction>;
    getStakeInstruction(feePayer: PublicKey, lockup: PublicKey, stakeToken: PublicKey, stakeVault: PublicKey, staker: PublicKey, userNonce: PublicKey, stakePda: PublicKey, stakeVaultTokenAccount: PublicKey, data: StakeInstructionData): Promise<TransactionInstruction>;
    getUnstakeInstruction(feePayer: PublicKey, feeVault: PublicKey, lockup: PublicKey, stakePda: PublicKey, rewardToken: PublicKey, rewardVault: PublicKey, stakeToken: PublicKey, stakeVault: PublicKey, staker: PublicKey, stakerTokenAccount: PublicKey, nonce: BN): Promise<TransactionInstruction>;
    initLockup(params: {
        stakeToken: Address;
        rewardToken: Address;
        creator?: Address;
        name: string;
        fee: Numeric;
        feeVault: Address;
        rewardSchemes: RewardScheme[];
        minimumStake: Numeric;
    }): Promise<TransactionPayload>;
    stake(params: {
        lockupName: string;
        feePayer?: Address;
        staker?: Address;
        amount: Numeric;
        lockPeriod: number;
        nonce: bigint;
    }): Promise<TransactionPayload>;
    unstake(params: {
        lockupName: string;
        nonce: bigint;
        feePayer?: Address;
        staker?: Address;
    }): Promise<TransactionPayload>;
    getLockupInfo(lockupAddress: Address): Promise<LockupInfo | null>;
    getStakeInfo(stakeAddress: Address, lockupAddress: Address): Promise<StakeInfo | null>;
    getUserNonceInfo(userNonceAddress: Address): Promise<UserNonceInfo | null>;
    getAllStakesInfoOfUser(userAdress: Address, lockupAddress: Address, options?: {
        minDelayMs?: number;
        maxConcurrent?: number;
    }): Promise<StakeInfoWithHash[]>;
    getAllStakesCount(lockupAddress: Address): Promise<number>;
    getStakeSignatureForStake(stakeInfo: StakeInfo): Promise<string | null>;
    getAllStakesInfo(lockupAddress: Address): Promise<StakeInfo[]>;
    get programId(): PublicKey;
    get connection(): Connection;
}
export type InitLockupInstructionData = {
    rewardSchemes: ParsedRewardScheme[];
    fee: BN;
    feeVault: PublicKey;
    name: string;
    minimumStake: BN;
};
export type ParsedRewardScheme = {
    duration: BN;
    reward: BN;
};
type Numeric = string | number;
export type RewardScheme = {
    duration: number;
    rewardRate: Numeric;
};
export type StakeInstructionData = {
    amount: BN;
    lockPeriod: BN;
    nonce: BN;
};
export type LockupInfo = {
    address: string;
    feeInfo: {
        fee: string;
        feeVault: string;
    };
    rewardToken: {
        tokenAddress: string;
    };
    stakeToken: {
        tokenAdress: string;
        totalStaked: string;
    };
    stakeInfo: {
        name: string;
        creator: string;
        rewardSchemes: RewardScheme[];
        minimumStake: string;
    };
};
export type StakeInfo = {
    address: string;
    nonce: bigint;
    createdTime: number;
    stakedAmount: string;
    rewardAmount: string;
    stakeClaimed: boolean;
    lockPeriod: number;
    staker: string;
    lockup: string;
};
export type UserNonceInfo = {
    address: string;
    nonce: bigint;
};
export type StakeInfoWithHash = StakeInfo & {
    hash: string;
};
export {};