@zebec-network/zebec-stake-sdk 1.2.2 → 1.3.1

package/dist/service.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StakeService = exports.StakeServiceBuilder = void 0;
-const assert_1 = __importDefault(require("assert"));
-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 assert_1 = __importDefault(require("assert"));
+const bignumber_js_1 = require("bignumber.js");
 const artifacts_1 = require("./artifacts");
 const pda_1 = require("./pda");
 const providers_1 = require("./providers");
@@ -89,7 +89,9 @@ class StakeServiceBuilder {
         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);
+        this._program = !createProgram
+            ? new anchor_1.Program(artifacts_1.ZEBEC_STAKE_IDL_V1, this._provider)
+            : createProgram(this._provider);
         return this;
     }
     build() {
@@ -117,8 +119,8 @@ class StakeService {
     }
     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;
+        this.program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
+        let signTransaction;
         const provider = this.provider;
         if (provider instanceof anchor_1.AnchorProvider) {
             signTransaction = async (tx) => {
@@ -193,7 +195,9 @@ class StakeService {
             .instruction();
     }
     async initLockup(params) {
-        const creator = params.creator ? (0, anchor_1.translateAddress)(params.creator) : this.provider.publicKey;
+        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");
         }
@@ -223,7 +227,9 @@ class StakeService {
         return this._createPayload(creator, [instruction]);
     }
     async updateLockup(params) {
-        const updater = params.updater ? (0, anchor_1.translateAddress)(params.updater) : this.provider.publicKey;
+        const updater = params.updater
+            ? (0, anchor_1.translateAddress)(params.updater)
+            : this.provider.publicKey;
         if (!updater) {
             throw new Error("MissingArgument: Please provide either updater address or publicKey in provider");
         }
@@ -250,19 +256,23 @@ class StakeService {
         return this._createPayload(updater, [instruction]);
     }
     async stake(params) {
-        const staker = params.staker ? (0, anchor_1.translateAddress)(params.staker) : this.provider.publicKey;
+        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 feePayer = params.feePayer ? (0, anchor_1.translateAddress)(params.feePayer) : staker;
+        const feePayer = params.feePayer
+            ? (0, anchor_1.translateAddress)(params.feePayer)
+            : staker;
         const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.programId);
         const lockupAccount = await this.program.account.lockup.fetchNullable(lockup, this.connection.commitment);
         if (!lockupAccount) {
-            throw new Error("Lockup account does not exists for address: " + lockup);
+            throw new Error(`Lockup account does not exists for address: ${lockup}`);
         }
         const lockPeriods = lockupAccount.stakeInfo.durationMap.map((item) => item.duration.toNumber());
         if (!lockPeriods.includes(params.lockPeriod)) {
-            throw new Error("Invalid lockperiod. Available options are: " + lockPeriods.map((l) => l.toString()).concat(", "));
+            throw new Error(`Invalid lockperiod. Available options are: ${lockPeriods.map((l) => l.toString()).join(", ")}`);
         }
         const stakeToken = lockupAccount.stakedToken.tokenAddress;
         const stakeVault = (0, pda_1.deriveStakeVaultAddress)(lockup, this.programId);
@@ -284,11 +294,15 @@ class StakeService {
         return this._createPayload(feePayer, [instruction]);
     }
     async unstake(params) {
-        const staker = params.staker ? (0, anchor_1.translateAddress)(params.staker) : this.provider.publicKey;
+        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 feePayer = params.feePayer ? (0, anchor_1.translateAddress)(params.feePayer) : staker;
+        const feePayer = params.feePayer
+            ? (0, anchor_1.translateAddress)(params.feePayer)
+            : staker;
         const lockup = (0, pda_1.deriveLockupAddress)(params.lockupName, this.programId);
         const lockupAccount = await this.program.account.lockup.fetchNullable(lockup, this.connection.commitment);
         if (!lockupAccount) {
@@ -315,7 +329,9 @@ class StakeService {
         return {
             address: lockupAddress.toString(),
             feeInfo: {
-                fee: (0, bignumber_js_1.BigNumber)(lockupAccount.feeInfo.fee.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+                fee: (0, bignumber_js_1.BigNumber)(lockupAccount.feeInfo.fee.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
                 feeVault: lockupAccount.feeInfo.feeVault.toString(),
             },
             rewardToken: {
@@ -323,7 +339,9 @@ class StakeService {
             },
             stakeToken: {
                 tokenAdress: lockupAccount.stakedToken.tokenAddress.toString(),
-                totalStaked: (0, bignumber_js_1.BigNumber)(lockupAccount.stakedToken.totalStaked.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+                totalStaked: (0, bignumber_js_1.BigNumber)(lockupAccount.stakedToken.totalStaked.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
             },
             stakeInfo: {
                 name: lockupAccount.stakeInfo.name,
@@ -332,7 +350,9 @@ class StakeService {
                     duration: value.duration.toNumber(),
                     rewardRate: (0, core_utils_1.bpsToPercent)(value.reward.toString()),
                 })),
-                minimumStake: (0, bignumber_js_1.BigNumber)(lockupAccount.stakeInfo.minimumStake.toString()).div(UNITS_PER_STAKE_TOKEN).toFixed(),
+                minimumStake: (0, bignumber_js_1.BigNumber)(lockupAccount.stakeInfo.minimumStake.toString())
+                    .div(UNITS_PER_STAKE_TOKEN)
+                    .toFixed(),
             },
         };
     }
@@ -355,8 +375,12 @@ class StakeService {
             address: stakeAddress.toString(),
             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(),
+            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(),
             lockup: stakeAccount.lockup.toString(),
@@ -393,20 +417,27 @@ class StakeService {
         const nonces = Array.from({ length: currentNonce }, (_, i) => BigInt(i));
         const stakeAddresses = nonces.map((nonce) => (0, pda_1.deriveStakeAddress)(userAdress, lockupAddress, nonce, this.programId));
         const stakeAddressesChunks = (0, utils_1.chunkArray)(stakeAddresses, 100);
-        let stakeWithHash2D = [];
+        const stakeWithHash2D = [];
         for (const stakeAddresses of stakeAddressesChunks) {
             const accountInfos = await this.connection.getMultipleAccountsInfo(stakeAddresses, {
                 commitment: this.connection.commitment,
             });
             const stakeAccountsInfo = accountInfos.map((value, i) => {
-                (0, assert_1.default)(value, "Account does not exists for stake address: " + stakeAddresses[i] + " at nonce: " + nonces[i]);
+                (0, assert_1.default)(value, "Account does not exists for stake address: " +
+                    stakeAddresses[i] +
+                    " at nonce: " +
+                    nonces[i]);
                 const stakeAccount = this.program.coder.accounts.decode(this.program.idl.accounts[2].name, value.data);
                 const info = {
                     address: stakeAddresses[i].toString(),
                     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(),
+                    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(),
                     lockup: stakeAccount.lockup.toString(),
@@ -414,7 +445,7 @@ class StakeService {
                 };
                 return info;
             });
-            let stakesWithHash = new Array(stakeAccountsInfo.length);
+            const stakesWithHash = new Array(stakeAccountsInfo.length);
             const { maxConcurrent = 3, minDelayMs = 400 } = options;
             const queue = new rateLimitQueue_1.RateLimitedQueue(maxConcurrent, minDelayMs); // Max 3 concurrent, 300ms between requests
             const promises = stakeAccountsInfo.map((stakeInfo, index) => queue.add(async () => {
@@ -492,8 +523,12 @@ class StakeService {
                 address: accountInfo.pubkey.toString(),
                 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(),
+                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(),
                 lockup: stakeAccount.lockup.toString(),

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+import type { PublicKey } from "@solana/web3.js";
+import type BN from "bn.js";
+export type InitLockupInstructionData = {
+    rewardSchemes: ParsedRewardScheme[];
+    fee: BN;
+    feeVault: PublicKey;
+    name: string;
+    minimumStake: BN;
+};
+export type UpdateLockupInstructionData = {
+    rewardSchemes: ParsedRewardScheme[];
+    fee: BN;
+    feeVault: PublicKey;
+    minimumStake: BN;
+};
+export type ParsedRewardScheme = {
+    duration: BN;
+    reward: BN;
+};
+export 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;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.js

@@ -17,9 +17,11 @@ async function callWithEnhancedBackoff(fn, maxRetries = MAX_RETRIES, backoffFact
         catch (error) {
             if (attempt === maxRetries)
                 throw error;
-            let delay = Math.min(baseDelay * Math.pow(backoffFactor, attempt), maxDelay);
+            let delay = Math.min(baseDelay * backoffFactor ** attempt, maxDelay);
             // Handle 429 specifically with longer delays
-            if (error?.status === 429 || error?.code === 429 || error?.message?.includes("429")) {
+            if (error?.status === 429 ||
+                error?.code === 429 ||
+                error?.message?.includes("429")) {
                 delay = Math.min(delay * backoffFactor, maxDelay); // Double delay for rate limits
                 console.warn(`Rate limit hit, waiting ${delay}ms before retry ${attempt + 1}/${maxRetries}`);
             }

package/package.json

@@ -1,47 +1,47 @@
-{
-  "name": "@zebec-network/zebec-stake-sdk",
-  "version": "1.2.2",
-  "description": "An SDK for zebec network stake solana program",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "author": "Zebec Network | 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 1000000000 test/**/*.test.ts",
-    "test:single": "ts-mocha -p ./tsconfig.json -t 1000000000"
-  },
-  "dependencies": {
-    "@coral-xyz/anchor": "^0.31.1",
-    "@solana/web3.js": "^1.98.2",
-    "@zebec-network/core-utils": "^1.1.1",
-    "@zebec-network/solana-common": "^2.3.1",
-    "bignumber.js": "^9.3.1",
-    "buffer": "^6.0.3"
-  },
-  "devDependencies": {
-    "@types/bn.js": "^5.2.0",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^25.0.3",
-    "dotenv": "^17.2.3",
-    "mocha": "^11.7.5",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.1.2",
-    "ts-mocha": "^11.1.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.2"
-  }
+{
+	"author": "Zebec Network | Ashish Sapkota",
+	"dependencies": {
+		"@coral-xyz/anchor": "^0.31.1",
+		"@solana/web3.js": "^1.98.2",
+		"@zebec-network/core-utils": "^1.1.1",
+		"@zebec-network/solana-common": "^2.3.1",
+		"bignumber.js": "^9.3.1",
+		"buffer": "^6.0.3"
+	},
+	"description": "An SDK for zebec network stake solana program",
+	"devDependencies": {
+		"@types/bn.js": "^5.2.0",
+		"@types/mocha": "^10.0.10",
+		"@types/node": "^25.0.3",
+		"dotenv": "^17.2.3",
+		"mocha": "^11.7.5",
+		"prettier": "^3.6.2",
+		"rimraf": "^6.1.2",
+		"ts-mocha": "^11.1.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.9.2"
+	},
+	"files": [
+		"dist"
+	],
+	"keywords": [
+		"solana",
+		"zebec",
+		"zebec network",
+		"stake",
+		"staking"
+	],
+	"license": "MIT",
+	"main": "dist/index.js",
+	"name": "@zebec-network/zebec-stake-sdk",
+	"scripts": {
+		"build": "npm run clean && tsc",
+		"clean": "rimraf ./dist",
+		"format": "npx @biomejs/biome format --write",
+		"start": "ts-node src/index.ts",
+		"test": "ts-mocha -p ./tsconfig.json -t 1000000000 test/**/*.test.ts",
+		"test:single": "ts-mocha -p ./tsconfig.json -t 1000000000"
+	},
+	"types": "dist/index.d.ts",
+	"version": "1.3.1"
 }