@zebec-network/zebec-stake-sdk 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const isSdkEnvDev: boolean;
+/**
+ * Zebec Card Program Ids
+ */
+export declare const ZEBEC_STAKE_PROGRAM: {
+    /** Mainnet Program Id */
+    mainnet: string;
+    /** Devnet Program Id */
+    devnet: string;
+};
+export declare const ZBCN: PublicKey;
+/** BigNumber Object for 10 */
+export declare const TEN_BIGNUM: BigNumber;
+/** Token Program ID */
+export declare const TOKEN_PROGRAM_ID: PublicKey;
+/** Associated Token Program ID */
+export declare const ASSOCIATED_TOKEN_PROGRAM_ID: PublicKey;

package/dist/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSOCIATED_TOKEN_PROGRAM_ID = exports.TOKEN_PROGRAM_ID = exports.TEN_BIGNUM = exports.ZBCN = exports.ZEBEC_STAKE_PROGRAM = exports.isSdkEnvDev = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const dotenv_1 = __importDefault(require("dotenv"));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+dotenv_1.default.config();
+const SDK_ENV = process.env.SDK_ENV ?? "production";
+exports.isSdkEnvDev = SDK_ENV === "development";
+/**
+ * Zebec Card Program Ids
+ */
+exports.ZEBEC_STAKE_PROGRAM = {
+    /** Mainnet Program Id */
+    mainnet: "6S5tbu8jPJKFvpBMjaMPQbcwcrw8iHcuGnXH8ZwHgwaE",
+    /** Devnet Program Id */
+    devnet: "6S5tbu8jPJKFvpBMjaMPQbcwcrw8iHcuGnXH8ZwHgwaE",
+};
+exports.ZBCN = new web3_js_1.PublicKey("ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU");
+/** BigNumber Object for 10 */
+exports.TEN_BIGNUM = (0, bignumber_js_1.BigNumber)(10);
+/** Token Program ID */
+exports.TOKEN_PROGRAM_ID = anchor_1.utils.token.TOKEN_PROGRAM_ID;
+/** Associated Token Program ID */
+exports.ASSOCIATED_TOKEN_PROGRAM_ID = anchor_1.utils.token.ASSOCIATED_PROGRAM_ID;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./constants";
+export * from "./artifacts";
+export * from "./service";
+export * from "./providers";
+export * from "./pda";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./artifacts"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./providers"), exports);
+__exportStar(require("./pda"), exports);

package/dist/pda.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export declare function deriveStakeAddress(staker: Address, lockup: Address, nonce: bigint, programId?: Address): PublicKey;
+export declare function deriveLockupAddress(name: string, programId?: Address): PublicKey;
+export declare function deriveUserNonceAddress(user: Address, lockup: Address, programId?: Address): PublicKey;
+export declare function deriveStakeVaultAddress(lockup: Address, programId?: Address): PublicKey;
+export declare function deriveRewardVaultAddress(lockup: Address, programId?: Address): PublicKey;

package/dist/pda.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveStakeAddress = deriveStakeAddress;
+exports.deriveLockupAddress = deriveLockupAddress;
+exports.deriveUserNonceAddress = deriveUserNonceAddress;
+exports.deriveStakeVaultAddress = deriveStakeVaultAddress;
+exports.deriveRewardVaultAddress = deriveRewardVaultAddress;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const SEEDS = {
+    lockup: "zebec_lockup",
+    stakeVault: "stake_vault",
+    rewardVault: "reward_vault",
+};
+function deriveStakeAddress(staker, lockup, nonce, programId = constants_1.ZEBEC_STAKE_PROGRAM.mainnet) {
+    const [stakeAddress] = web3_js_1.PublicKey.findProgramAddressSync([
+        (0, anchor_1.translateAddress)(staker).toBuffer(),
+        (0, anchor_1.translateAddress)(lockup).toBuffer(),
+        new anchor_1.BN(nonce.toString()).toArrayLike(Buffer, "le", 8),
+    ], (0, anchor_1.translateAddress)(programId));
+    return stakeAddress;
+}
+function deriveLockupAddress(name, programId = constants_1.ZEBEC_STAKE_PROGRAM.mainnet) {
+    const [lockupAddress] = web3_js_1.PublicKey.findProgramAddressSync([anchor_1.utils.bytes.utf8.encode(SEEDS.lockup), anchor_1.utils.bytes.utf8.encode(name)], (0, anchor_1.translateAddress)(programId));
+    return lockupAddress;
+}
+function deriveUserNonceAddress(user, lockup, programId = constants_1.ZEBEC_STAKE_PROGRAM.mainnet) {
+    const [userNonceAddress] = web3_js_1.PublicKey.findProgramAddressSync([(0, anchor_1.translateAddress)(user).toBuffer(), (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return userNonceAddress;
+}
+function deriveStakeVaultAddress(lockup, programId = constants_1.ZEBEC_STAKE_PROGRAM.mainnet) {
+    const [stakeVault] = web3_js_1.PublicKey.findProgramAddressSync([anchor_1.utils.bytes.utf8.encode(SEEDS.stakeVault), (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return stakeVault;
+}
+function deriveRewardVaultAddress(lockup, programId = constants_1.ZEBEC_STAKE_PROGRAM.mainnet) {
+    const [rewardVault] = web3_js_1.PublicKey.findProgramAddressSync([anchor_1.utils.bytes.utf8.encode(SEEDS.rewardVault), (0, anchor_1.translateAddress)(lockup).toBuffer()], (0, anchor_1.translateAddress)(programId));
+    return rewardVault;
+}

package/dist/providers.d.ts

@@ -0,0 +1,17 @@
+import { Address, AnchorProvider } from "@coral-xyz/anchor";
+import { ConfirmOptions, Connection, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+export declare class ReadonlyProvider {
+    readonly connection: Connection;
+    readonly walletAddress?: PublicKey;
+    constructor(connection: Connection, walletAddress?: Address);
+}
+export declare function createReadonlyProvider(connection: Connection, walletAddress?: Address): ReadonlyProvider;
+/**
+ * Wallet interface used by Anchor Framework
+ */
+export interface AnchorWallet {
+    signTransaction: <T extends Transaction | VersionedTransaction>(tx: T) => Promise<T>;
+    signAllTransactions: <T extends Transaction | VersionedTransaction>(txs: T[]) => Promise<T[]>;
+    publicKey: PublicKey;
+}
+export declare function createAnchorProvider(connection: Connection, wallet: AnchorWallet, options?: ConfirmOptions): AnchorProvider;

package/dist/providers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyProvider = void 0;
+exports.createReadonlyProvider = createReadonlyProvider;
+exports.createAnchorProvider = createAnchorProvider;
+const anchor_1 = require("@coral-xyz/anchor");
+class ReadonlyProvider {
+    connection;
+    walletAddress;
+    constructor(connection, walletAddress) {
+        this.connection = connection;
+        this.walletAddress = walletAddress ? (0, anchor_1.translateAddress)(walletAddress) : undefined;
+    }
+}
+exports.ReadonlyProvider = ReadonlyProvider;
+function createReadonlyProvider(connection, walletAddress) {
+    return new ReadonlyProvider(connection, walletAddress);
+}
+function createAnchorProvider(connection, wallet, options) {
+    return new anchor_1.AnchorProvider(connection, wallet, {
+        ...anchor_1.AnchorProvider.defaultOptions(),
+        ...options,
+    });
+}

package/dist/service.d.ts

@@ -0,0 +1,123 @@
+import { Address, AnchorProvider, BN, Program, Provider } from "@coral-xyz/anchor";
+import { 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(lockup: PublicKey, stakeToken: PublicKey, stakeVault: PublicKey, staker: PublicKey, userNonce: PublicKey, stakePda: PublicKey, stakeVaultTokenAccount: PublicKey, data: StakeInstructionData): Promise<TransactionInstruction>;
+    getUnstakeInstruction(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[];
+    }): Promise<TransactionPayload>;
+    stake(params: {
+        lockupName: string;
+        staker?: Address;
+        amount: Numeric;
+        lockPeriod: number;
+        nonce: bigint;
+    }): Promise<TransactionPayload>;
+    unstake(params: {
+        lockupName: string;
+        nonce: bigint;
+        staker?: Address;
+    }): Promise<TransactionPayload>;
+    getLockupInfo(lockupAddress: Address): Promise<LockupInfo | null>;
+    getStakeInfo(stakeAddress: Address, lockupAddress: Address): Promise<StakeInfo | null>;
+    getUserNonceInfo(userNonceAddress: Address): Promise<UserNonceInfo | null>;
+}
+export type InitLockupInstructionData = {
+    rewardSchemes: ParsedRewardScheme[];
+    fee: BN;
+    feeVault: PublicKey;
+    name: string;
+};
+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 = {
+    feeInfo: {
+        fee: string;
+        feeVault: string;
+    };
+    rewardToken: {
+        tokenAddress: string;
+    };
+    stakeToken: {
+        tokenAdress: string;
+        totalStaked: string;
+    };
+    stakeInfo: {
+        name: string;
+        creator: string;
+        rewardSchemes: RewardScheme[];
+    };
+};
+export type StakeInfo = {
+    nonce: bigint;
+    createdTime: number;
+    stakedAmount: string;
+    rewardAmount: string;
+    stakeClaimed: boolean;
+    lockPeriod: number;
+};
+export type UserNonceInfo = {
+    nonce: bigint;
+};
+export {};

package/dist/service.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakeService = exports.StakeServiceBuilder = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const core_utils_1 = require("@zebec-network/core-utils");
+const solana_common_1 = require("@zebec-network/solana-common");
+const artifacts_1 = require("./artifacts");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+const providers_1 = require("./providers");
+/**
+ * StakeServiceBuilder is a builder class for creating a StakeService instance.
+ * It allows you to set the network, provider, and program to use.
+ */
+class StakeServiceBuilder {
+    _program;
+    _provider;
+    _network;
+    /**
+     *
+     * @param network The network to use. If not set, a default network: 'mainnet-beta' will be used.
+     * @returns
+     */
+    setNetwork(network) {
+        if (this._network) {
+            throw new Error("InvalidOperation: Network is set twice.");
+        }
+        this._network = network ? network : "mainnet-beta";
+        return this;
+    }
+    /**
+     * 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) {
+        if (this._provider) {
+            throw new Error("InvalidOperation: Provider is set twice.");
+        }
+        if (!this._network) {
+            throw new Error("InvalidOperation: Network is not set. Please set the network before setting the provider.");
+        }
+        if (provider) {
+            this.validateProviderNetwork(provider, this._network);
+            this._provider = provider;
+        }
+        else {
+            this._provider = (0, providers_1.createReadonlyProvider)(new web3_js_1.Connection((0, web3_js_1.clusterApiUrl)(this._network)));
+        }
+        return this;
+    }
+    /**
+     *
+     * @param provider The provider to compare with.
+     */
+    validateProviderNetwork(provider, network) {
+        const connection = provider.connection;
+        const rpcEndpoint = connection.rpcEndpoint;
+        const connNetwork = rpcEndpoint.includes("devnet")
+            ? "devnet"
+            : rpcEndpoint.includes("testnet")
+                ? "testnet"
+                : rpcEndpoint.includes("localhost:8899")
+                    ? "localnet"
+                    : "mainnet-beta";
+        if (network !== connNetwork) {
+            throw new Error(`InvalidOperation: Network mismatch. network and connection network should be same. network: ${this._network}, connection: ${connNetwork}`);
+        }
+    }
+    /**
+     * 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) {
+        if (this._program) {
+            throw new Error("InvalidOperation: Program is set twice.");
+        }
+        if (!this._network) {
+            throw new Error("InvalidOperation: Network is not set. Please set the network before setting the provider.");
+        }
+        if (!this._provider) {
+            throw new Error("InvalidOperation: Provider is not set. Please set the provider before setting the program.");
+        }
+        this._program = !createProgram ? new anchor_1.Program(artifacts_1.ZEBEC_STAKE_IDL_V1, this._provider) : createProgram(this._provider);
+        return this;
+    }
+    build() {
+        if (!this._network) {
+            throw new Error("InvalidOperation: Network is not set. Please set the network before building the service.");
+        }
+        if (!this._provider) {
+            throw new Error("InvalidOperation: Provider is not set. Please set the provider before building the service.");
+        }
+        if (!this._program) {
+            throw new Error("InvalidOperation: Program is not set. Please set the program before building the service.");
+        }
+        return new StakeService(this._provider, this._program, this._network);
+    }
+}
+exports.StakeServiceBuilder = StakeServiceBuilder;
+class StakeService {
+    provider;
+    program;
+    network;
+    constructor(provider, program, network) {
+        this.provider = provider;
+        this.program = program;
+        this.network = network;
+    }
+    async _createPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        let signTransaction = undefined;
+        const provider = this.provider;
+        if (provider instanceof anchor_1.AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
+            };
+        }
+        return new solana_common_1.TransactionPayload(this.provider.connection, errorMap, instructions, payerKey, signers, addressLookupTableAccounts, signTransaction);
+    }
+    async getInitLockupInstruction(creator, lockup, stakeToken, rewardToken, rewardVault, stakeVault, data) {
+        return this.program.methods
+            .initLockup({
+            fee: data.fee,
+            durationMap: data.rewardSchemes,
+            feeVault: data.feeVault,
+            name: data.name,
+        })
+            .accountsPartial({
+            creator,
+            lockup,
+            rewardToken,
+            rewardVault,
+            stakeToken,
+            stakeVault,
+        })
+            .instruction();
+    }
+    async getStakeInstruction(lockup, stakeToken, stakeVault, staker, userNonce, stakePda, stakeVaultTokenAccount, data) {
+        return this.program.methods
+            .stakeZbcn(data)
+            .accountsPartial({ stakeToken, staker, lockup, stakeVault, userNonce, stakePda, stakeVaultTokenAccount })
+            .instruction();
+    }
+    async getUnstakeInstruction(feeVault, lockup, stakePda, rewardToken, rewardVault, stakeToken, stakeVault, staker, stakerTokenAccount, nonce) {
+        return this.program.methods
+            .unstakeZbcn(nonce)
+            .accountsPartial({
+            feeVault,
+            rewardToken,
+            stakeToken,
+            staker,
+            lockup,
+            stakeVault,
+            stakePda,
+            rewardVault,
+            stakerTokenAccount,
+        })
+            .instruction();
+    }
+    async initLockup(params) {
+        const creator = params.creator ? (0, anchor_1.translateAddress)(params.creator) : this.provider.publicKey;
+        if (!creator) {
+            throw new Error("MissingArgument: Please provide either creator address or publicKey in provider");
+        }
+        const stakeToken = (0, anchor_1.translateAddress)(params.stakeToken);
+        const rewardToken = (0, anchor_1.translateAddress)(params.rewardToken);
+        const feeVault = (0, anchor_1.translateAddress)(params.feeVault);
+        const stakeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, stakeToken);
+        const rewardSchemes = params.rewardSchemes.map((value) => {
+            return {
+                duration: new anchor_1.BN(value.duration),
+                reward: new anchor_1.BN((0, core_utils_1.percentToBps)(value.rewardRate)),
+            };
+        });
+        const lockup = (0, pda_1.deriveLockupAddress)(params.name, this.program.programId);
+        const rewardVault = (0, pda_1.deriveRewardVaultAddress)(lockup, this.program.programId);
+        const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.program.programId);
+        const fee = new anchor_1.BN((0, bignumber_js_1.BigNumber)(params.fee).times(constants_1.TEN_BIGNUM.pow(stakeTokenDecimals)).toFixed());
+        const instruction = await this.getInitLockupInstruction(creator, lockup, stakeToken, rewardToken, rewardVault, stakeVault, {
+            fee,
+            feeVault: feeVault,
+            name: params.name,
+            rewardSchemes,
+        });
+        return this._createPayload(creator, [instruction]);
+    }
+    async stake(params) {
+        const staker = params.staker ? (0, anchor_1.translateAddress)(params.staker) : this.provider.publicKey;
+        if (!staker) {
+            throw new Error("MissingArgument: Please provide either staker address or publicKey in provider");
+        }
+        const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.program.programId);
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockup, this.provider.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error("Lockup account does not exists for address: " + lockup);
+        }
+        const stakeToken = lockupAccount.stakedToken.tokenAddress;
+        const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.program.programId);
+        const userNonce = (0, pda_1.deriveUserNonceAddress)(staker, lockup, this.program.programId);
+        const userNonceAccount = await this.program.account.userNonce.fetchNullable(userNonce, this.provider.connection.commitment);
+        let nonce = BigInt(0);
+        if (userNonceAccount) {
+            nonce = BigInt(userNonceAccount.nonce.toString());
+        }
+        const stakePda = (0, pda_1.deriveStakeAddress)(staker, lockup, nonce, this.program.programId);
+        const stakeVaultTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(stakeToken, stakeVault, true);
+        const stakeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, stakeToken);
+        const UNITS_PER_STAKE_TOKEN = constants_1.TEN_BIGNUM.pow(stakeTokenDecimals);
+        const instruction = await this.getStakeInstruction(lockup, stakeToken, stakeVault, staker, userNonce, stakePda, stakeVaultTokenAccount, {
+            amount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(params.amount).times(UNITS_PER_STAKE_TOKEN).toFixed(0)),
+            lockPeriod: new anchor_1.BN(params.lockPeriod),
+            nonce: new anchor_1.BN(params.nonce.toString()),
+        });
+        return this._createPayload(staker, [instruction]);
+    }
+    async unstake(params) {
+        const staker = params.staker ? (0, anchor_1.translateAddress)(params.staker) : this.provider.publicKey;
+        if (!staker) {
+            throw new Error("MissingArgument: Please provide either staker address or publicKey in provider");
+        }
+        const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.program.programId);
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockup, this.provider.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error("Lockup account does not exists for address: " + lockup);
+        }
+        const stakeToken = lockupAccount.stakedToken.tokenAddress;
+        const rewardToken = lockupAccount.rewardToken.tokenAddress;
+        const feeVault = lockupAccount.feeInfo.feeVault;
+        const stakePda = (0, pda_1.deriveStakeAddress)(staker, lockup, params.nonce, this.program.programId);
+        const rewardVault = (0, pda_1.deriveRewardVaultAddress)(lockup, this.program.programId);
+        const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.program.programId);
+        const stakerTokenAccount = (0, solana_common_1.getAssociatedTokenAddressSync)(stakeToken, staker);
+        const instruction = await this.getUnstakeInstruction(feeVault, lockup, stakePda, rewardToken, rewardVault, stakeToken, stakeVault, staker, stakerTokenAccount, new anchor_1.BN(params.nonce.toString()));
+        return this._createPayload(staker, [instruction]);
+    }
+    async getLockupInfo(lockupAddress) {
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockupAddress, this.provider.connection.commitment);
+        if (!lockupAccount) {
+            return null;
+        }
+        const stakeTokenAddress = lockupAccount.stakedToken.tokenAddress;
+        const stakeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, stakeTokenAddress);
+        const UNITS_PER_STAKE_TOKEN = constants_1.TEN_BIGNUM.pow(stakeTokenDecimals);
+        return {
+            feeInfo: {
+                fee: (0, bignumber_js_1.BigNumber)(lockupAccount.feeInfo.fee.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+                feeVault: lockupAccount.feeInfo.feeVault.toString(),
+            },
+            rewardToken: {
+                tokenAddress: lockupAccount.rewardToken.tokenAddress.toString(),
+            },
+            stakeToken: {
+                tokenAdress: lockupAccount.stakedToken.tokenAddress.toString(),
+                totalStaked: (0, bignumber_js_1.BigNumber)(lockupAccount.stakedToken.totalStaked.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+            },
+            stakeInfo: {
+                name: lockupAccount.stakeInfo.name,
+                creator: lockupAccount.stakeInfo.creator.toString(),
+                rewardSchemes: lockupAccount.stakeInfo.durationMap.map((value) => ({
+                    duration: value.duration.toNumber(),
+                    rewardRate: (0, core_utils_1.bpsToPercent)(value.reward.toString()),
+                })),
+            },
+        };
+    }
+    async getStakeInfo(stakeAddress, lockupAddress) {
+        const lockupAccount = await this.program.account.lockup.fetchNullable(lockupAddress, this.provider.connection.commitment);
+        if (!lockupAccount) {
+            throw new Error("Lockup account does not exists for address: " + lockupAddress);
+        }
+        const stakeTokenAddress = lockupAccount.stakedToken.tokenAddress;
+        const rewardTokenAddress = lockupAccount.rewardToken.tokenAddress;
+        const stakeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, stakeTokenAddress);
+        const rewardTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.provider.connection, rewardTokenAddress);
+        const UNITS_PER_STAKE_TOKEN = constants_1.TEN_BIGNUM.pow(stakeTokenDecimals);
+        const UNITS_PER_REWARD_TOKEN = constants_1.TEN_BIGNUM.pow(rewardTokenDecimals);
+        const stakeAccount = await this.program.account.userStakeData.fetchNullable(stakeAddress, this.provider.connection.commitment);
+        if (!stakeAccount) {
+            return null;
+        }
+        return {
+            nonce: BigInt(stakeAccount.nonce.toString()),
+            createdTime: stakeAccount.createdTime.toNumber(),
+            stakedAmount: (0, bignumber_js_1.BigNumber)(stakeAccount.stakedAmount.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+            rewardAmount: (0, bignumber_js_1.BigNumber)(stakeAccount.rewardAmount.toString()).div(UNITS_PER_REWARD_TOKEN).toFixed(),
+            stakeClaimed: stakeAccount.stakeClaimed,
+            lockPeriod: stakeAccount.lockPeriod.toNumber(),
+        };
+    }
+    async getUserNonceInfo(userNonceAddress) {
+        const userNonceAccount = await this.program.account.userNonce.fetchNullable(userNonceAddress, this.provider.connection.commitment);
+        if (!userNonceAccount) {
+            return null;
+        }
+        return {
+            nonce: BigInt(userNonceAccount.nonce.toString()),
+        };
+    }
+}
+exports.StakeService = StakeService;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@zebec-network/zebec-stake-sdk",
+  "version": "1.0.0",
+  "description": "An SDK for zebec network stake solana program",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Ashish Sapkota",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "solana",
+    "zebec",
+    "zebec network",
+    "stake",
+    "staking"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rimraf ./dist",
+    "format": "prettier --write .",
+    "start": "ts-node src/index.ts",
+    "test": "ts-mocha -p ./tsconfig.json -t 1000000"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@solana/web3.js": "1.98.2",
+    "@types/bn.js": "^5.1.6",
+    "@zebec-network/core-utils": "^1.0.4",
+    "@zebec-network/solana-common": "^1.2.6",
+    "bignumber.js": "^9.3.0",
+    "buffer": "^6.0.3",
+    "dotenv": "^16.5.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.14.1",
+    "mocha": "^11.1.0",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "ts-mocha": "^11.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}