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

An SDK for zebec network stake solana program

import { type Address, AnchorProvider, BN, Program, type Provider } from "@coral-xyz/anchor";
import { Connection, type PublicKey, type TransactionInstruction } from "@solana/web3.js";
import { TransactionPayload } from "@zebec-network/solana-common";
import { type ZebecStakeIdlV1 } from "./artifacts";
import { type ReadonlyProvider } from "./providers";
import type { InitLockupInstructionData, LockupInfo, Numeric, RewardScheme, StakeInfo, StakeInfoWithHash, StakeInstructionData, UpdateLockupInstructionData, UserNonceInfo } from "./types";
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>;
    getUpdateLockupInstruction(updater: PublicKey, lockup: PublicKey, data: UpdateLockupInstructionData): 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>;
    updateLockup(params: {
        lockupName: string;
        updater?: Address;
        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 {};