@streamflow/staking 7.0.0-alpha.10

package/dist/esm/solana/lib/rewards.js

@@ -0,0 +1,136 @@
+import { PublicKey } from "@solana/web3.js";
+// eslint-disable-next-line no-restricted-imports
+import BN from "bn.js";
+import { SCALE_PRECISION_FACTOR_BN } from "../constants.js";
+export const REWARD_AMOUNT_PRECISION_FACTOR = new BN("1000000000");
+export class RewardEntryAccumulator {
+    delegate;
+    lastAccountedTs;
+    claimedAmount;
+    accountedAmount;
+    rewardPool;
+    stakeEntry;
+    createdTs;
+    lastRewardAmount;
+    lastRewardPeriod;
+    buffer;
+    constructor(delegate) {
+        this.delegate = delegate;
+        this.lastAccountedTs = delegate.lastAccountedTs;
+        this.claimedAmount = delegate.claimedAmount;
+        this.accountedAmount = delegate.accountedAmount;
+        this.rewardPool = delegate.rewardPool;
+        this.stakeEntry = delegate.stakeEntry;
+        this.createdTs = delegate.createdTs;
+        this.buffer = delegate.buffer;
+        this.lastRewardAmount = delegate.lastRewardAmount;
+        this.lastRewardPeriod = delegate.lastRewardPeriod;
+    }
+    // Calculate accountable amount by calculating how many seconds have passed since last claim/stake time
+    getAccountableAmount(stakedTs, accountableTs, effectiveStakedAmount, rewardAmount, rewardPeriod) {
+        const lastAccountedTs = this.lastAccountedTs.gt(new BN(0)) ? this.lastAccountedTs : stakedTs;
+        const secondsPassed = accountableTs.sub(lastAccountedTs);
+        if (secondsPassed.lt(rewardPeriod)) {
+            return new BN(0);
+        }
+        const periodsPassed = secondsPassed.div(rewardPeriod);
+        const claimablePerEffectiveStake = periodsPassed.mul(rewardAmount);
+        const accountableAmount = claimablePerEffectiveStake.mul(effectiveStakedAmount).div(SCALE_PRECISION_FACTOR_BN);
+        return accountableAmount;
+    }
+    // Calculates claimable amount from accountable amount.
+    getClaimableAmount() {
+        const claimedAmount = this.claimedAmount.mul(REWARD_AMOUNT_PRECISION_FACTOR);
+        const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
+        const claimableAmount = nonClaimedAmount.div(REWARD_AMOUNT_PRECISION_FACTOR);
+        return claimableAmount;
+    }
+    // Get the time of the last unlock
+    getLastAccountedTs(stakedTs, claimableTs, rewardPeriod) {
+        const lastAccountedTs = this.lastAccountedTs.gtn(0) ? this.lastAccountedTs : stakedTs;
+        const totalSecondsPassed = claimableTs.sub(lastAccountedTs);
+        const periodsPassed = totalSecondsPassed.div(rewardPeriod);
+        const periodsToSeconds = periodsPassed.mul(rewardPeriod);
+        const currClaimTs = lastAccountedTs.add(periodsToSeconds);
+        return currClaimTs;
+    }
+    // Adds accounted amount
+    addAccountedAmount(accountedAmount) {
+        this.accountedAmount = this.accountedAmount.add(accountedAmount);
+    }
+    // Adds claimed amount
+    addClaimedAmount(claimedAmount) {
+        this.claimedAmount = this.claimedAmount.add(claimedAmount);
+    }
+}
+const createDefaultRewardEntry = (stakeEntry, rewardPool) => {
+    return {
+        stakeEntry: new PublicKey(stakeEntry.publicKey),
+        rewardPool: new PublicKey(rewardPool.publicKey),
+        createdTs: stakeEntry.account.createdTs,
+        lastAccountedTs: new BN(0),
+        lastRewardAmount: new BN(0),
+        lastRewardPeriod: new BN(0),
+        accountedAmount: new BN(0),
+        claimedAmount: new BN(0),
+        buffer: [],
+    };
+};
+export const calcRewards = (rewardEntryAccount, stakeEntryAccount, rewardPoolAccount) => {
+    const rewardEntry = rewardEntryAccount?.account ?? createDefaultRewardEntry(stakeEntryAccount, rewardPoolAccount);
+    const stakeEntry = stakeEntryAccount.account;
+    const rewardPool = rewardPoolAccount.account;
+    const rewardEntryAccumulator = new RewardEntryAccumulator(rewardEntry);
+    if (rewardEntryAccumulator.createdTs.lt(stakeEntry.createdTs)) {
+        throw new Error("InvalidRewardEntry");
+    }
+    const currTs = Math.floor(Date.now() / 1000);
+    const stakedTs = rewardPool.createdTs ? BN.max(stakeEntry.createdTs, rewardPool.createdTs) : stakeEntry.createdTs;
+    const claimableTs = stakeEntry.closedTs.gtn(0) ? stakeEntry.closedTs : new BN(currTs);
+    const amountUpdated = !rewardPool.rewardAmount.eq(rewardPool.lastRewardAmount) &&
+        rewardPool.lastAmountUpdateTs.gt(stakeEntry.createdTs) &&
+        rewardPool.lastAmountUpdateTs.gt(stakeEntry.closedTs);
+    const periodUpdated = !rewardPool.rewardPeriod.eq(rewardPool.lastRewardPeriod) &&
+        rewardPool.lastPeriodUpdateTs.gt(stakeEntry.createdTs) &&
+        rewardPool.lastPeriodUpdateTs.gt(stakeEntry.closedTs);
+    if (amountUpdated || periodUpdated) {
+        let firstUpdateTs, secondUpdateTs, rewardAmount, rewardPeriod;
+        if (amountUpdated && periodUpdated) {
+            if (rewardPool.lastAmountUpdateTs.lt(rewardPool.lastPeriodUpdateTs)) {
+                firstUpdateTs = rewardPool.lastAmountUpdateTs;
+                secondUpdateTs = rewardPool.lastPeriodUpdateTs;
+                rewardAmount = rewardPool.rewardAmount;
+                rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
+            }
+            else {
+                firstUpdateTs = rewardPool.lastPeriodUpdateTs;
+                secondUpdateTs = rewardPool.lastAmountUpdateTs;
+                rewardAmount = rewardEntryAccumulator.lastRewardAmount;
+                rewardPeriod = rewardPool.rewardPeriod;
+            }
+        }
+        else if (amountUpdated) {
+            firstUpdateTs = new BN(0);
+            secondUpdateTs = rewardPool.lastAmountUpdateTs;
+            rewardAmount = rewardEntryAccumulator.lastRewardAmount;
+            rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
+        }
+        else {
+            firstUpdateTs = new BN(0);
+            secondUpdateTs = rewardPool.lastPeriodUpdateTs;
+            rewardAmount = rewardEntryAccumulator.lastRewardAmount;
+            rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
+        }
+        if (firstUpdateTs.gtn(0)) {
+            const firstAccountableAmount = rewardEntryAccumulator.getAccountableAmount(stakedTs, firstUpdateTs, stakeEntry.effectiveAmount, rewardEntryAccumulator.lastRewardAmount, rewardEntryAccumulator.lastRewardPeriod);
+            rewardEntryAccumulator.addAccountedAmount(firstAccountableAmount);
+            rewardEntryAccumulator.lastAccountedTs = rewardEntryAccumulator.getLastAccountedTs(stakedTs, firstUpdateTs, rewardPool.lastRewardPeriod);
+        }
+        const secondAccountableAmount = rewardEntryAccumulator.getAccountableAmount(stakedTs, secondUpdateTs, stakeEntry.effectiveAmount, rewardAmount, rewardPeriod);
+        rewardEntryAccumulator.addAccountedAmount(secondAccountableAmount);
+        rewardEntryAccumulator.lastAccountedTs = rewardEntryAccumulator.getLastAccountedTs(stakedTs, secondUpdateTs, rewardPeriod);
+    }
+    const accountableAmount = rewardEntryAccumulator.getAccountableAmount(stakedTs, claimableTs, stakeEntry.effectiveAmount, rewardPool.rewardAmount, rewardPool.rewardPeriod);
+    rewardEntryAccumulator.addAccountedAmount(accountableAmount);
+    return rewardEntryAccumulator.getClaimableAmount();
+};

package/dist/esm/solana/types.d.ts

@@ -0,0 +1,66 @@
+import { Address, type IdlTypes } from "@coral-xyz/anchor";
+import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
+import { Keypair } from "@solana/web3.js";
+import { ITransactionSolanaExt } from "@streamflow/common/solana";
+import BN from "bn.js";
+import { RewardPool as RewardPoolIDL } from "./descriptor/reward_pool.js";
+import { StakePool as StakePoolIDL } from "./descriptor/stake_pool.js";
+import { FeeManager as FeeManagerIDL } from "./descriptor/fee_manager.js";
+export type StakePool = IdlTypes<StakePoolIDL>["stakePool"];
+export type StakeEntry = IdlTypes<StakePoolIDL>["stakeEntry"];
+export type RewardEntry = IdlTypes<RewardPoolIDL>["rewardEntry"];
+export type RewardPool = IdlTypes<RewardPoolIDL>["rewardPool"];
+export type FeeValue = IdlTypes<FeeManagerIDL>["feeValue"];
+export interface IInteractSolanaExt extends ITransactionSolanaExt {
+    invoker: SignerWalletAdapter | Keypair;
+}
+export interface BaseStakePoolArgs {
+    stakePool: Address;
+    stakePoolMint: Address;
+}
+interface TokenProgram {
+    tokenProgramId?: Address;
+}
+interface StakeBaseArgs extends BaseStakePoolArgs, TokenProgram {
+    nonce: number;
+}
+export type UnstakeArgs = StakeBaseArgs;
+export interface StakeArgs extends StakeBaseArgs {
+    amount: BN;
+    duration: BN;
+    payer?: Keypair;
+    authority?: Address;
+}
+export interface FundPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    amount: BN;
+    nonce: number;
+    rewardMint: Address;
+    feeValue: Address | null;
+}
+export interface CreateRewardEntryArgs extends BaseStakePoolArgs, TokenProgram {
+    depositNonce: number;
+    rewardPoolNonce: number;
+}
+export interface CreateRewardPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    stakePoolNonce: number;
+    rewardMint: Address;
+    nonce: number;
+    rewardAmount: BN;
+    rewardPeriod: BN;
+    permissionless: boolean;
+}
+export interface ClaimRewardPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    depositNonce: number;
+    rewardMint: Address;
+    rewardPoolNonce: number;
+}
+export interface CreateStakePoolArgs extends TokenProgram {
+    mint: Address;
+    nonce: number;
+    maxWeight: BN;
+    minDuration: BN;
+    maxDuration: BN;
+    permissionless?: boolean;
+    authority?: Keypair;
+}
+export {};

package/dist/esm/solana/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/solana/utils.d.ts

@@ -0,0 +1,11 @@
+import { TransferFeeConfig } from "@solana/spl-token";
+import { Connection } from "@solana/web3.js";
+import BN from "bn.js";
+export declare const calculateStakeWeight: (minDuration: BN, maxDuration: BN, maxWeight: BN, duration: BN) => BN;
+export declare const calculateFeeAmount: (amount: BN, fee?: BN) => BN;
+export declare const calculateDecimalsShift: (maxWeight: bigint, maxShift?: number) => number;
+export declare const divCeilN: (n: bigint, d: bigint) => bigint;
+export declare function calculateAmountWithTransferFees(connection: Connection, transferFeeConfig: TransferFeeConfig, transferAmount: bigint): Promise<{
+    transferAmount: bigint;
+    feeCharged: bigint;
+}>;

package/dist/esm/solana/utils.js

@@ -0,0 +1,50 @@
+// eslint-disable-next-line no-restricted-imports
+import BN from "bn.js";
+import { DEFAULT_FEE_BN, FEE_PRECISION_FACTOR_BN, SCALE_PRECISION_FACTOR, SCALE_PRECISION_FACTOR_BN, U64_MAX, } from "./constants.js";
+export const calculateStakeWeight = (minDuration, maxDuration, maxWeight, duration) => {
+    const durationSpan = maxDuration.sub(minDuration);
+    if (durationSpan.eq(new BN(0))) {
+        return SCALE_PRECISION_FACTOR_BN;
+    }
+    const durationExceedingMin = duration.sub(minDuration);
+    const normalizedWeight = durationExceedingMin.mul(SCALE_PRECISION_FACTOR_BN).div(durationSpan);
+    const weightDiff = maxWeight.sub(SCALE_PRECISION_FACTOR_BN);
+    return BN.max(SCALE_PRECISION_FACTOR_BN.add(normalizedWeight.mul(weightDiff).div(SCALE_PRECISION_FACTOR_BN)), SCALE_PRECISION_FACTOR_BN);
+};
+export const calculateFeeAmount = (amount, fee = DEFAULT_FEE_BN) => {
+    if (fee.eq(FEE_PRECISION_FACTOR_BN)) {
+        return amount;
+    }
+    return amount.mul(fee).div(FEE_PRECISION_FACTOR_BN);
+};
+export const calculateDecimalsShift = (maxWeight, maxShift = 999) => {
+    if (maxShift == 0) {
+        return 0;
+    }
+    let decimalsShift = 0;
+    while ((maxWeight * U64_MAX) / BigInt(SCALE_PRECISION_FACTOR) / BigInt(10 ** decimalsShift) > U64_MAX) {
+        decimalsShift += 1;
+        if (decimalsShift == maxShift) {
+            return maxShift;
+        }
+    }
+    return decimalsShift;
+};
+export const divCeilN = (n, d) => n / d + (n % d ? BigInt(1) : BigInt(0));
+export async function calculateAmountWithTransferFees(connection, transferFeeConfig, transferAmount) {
+    const epoch = await connection.getEpochInfo();
+    const transferFee = epoch.epoch >= transferFeeConfig.newerTransferFee.epoch
+        ? transferFeeConfig.newerTransferFee
+        : transferFeeConfig.olderTransferFee;
+    const transferFeeBasisPoints = BigInt(transferFee.transferFeeBasisPoints);
+    let feeCharged = BigInt(0);
+    if (transferFeeBasisPoints !== BigInt(0)) {
+        const numerator = transferAmount * 10000n;
+        const denominator = 10000n - transferFeeBasisPoints;
+        const rawPreFeeAmount = divCeilN(numerator, denominator);
+        const fee = rawPreFeeAmount - transferAmount;
+        transferAmount = rawPreFeeAmount;
+        feeCharged = fee > transferFee.maximumFee ? transferFee.maximumFee : fee;
+    }
+    return { transferAmount, feeCharged };
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@streamflow/staking",
+  "version": "7.0.0-alpha.10",
+  "description": "JavaScript SDK to interact with Streamflow Staking protocol.",
+  "homepage": "https://github.com/streamflow-finance/js-sdk/",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    },
+    "./solana": {
+      "import": "./dist/esm/solana/index.js",
+      "require": "./dist/cjs/solana/index.js",
+      "types": "./dist/esm/solana/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build:cjs": "rm -rf dist/cjs; tsc -p tsconfig.cjs.json",
+    "build:esm": "rm -rf dist/esm; tsc -p tsconfig.esm.json",
+    "build": "rm -rf dist; pnpm run build:cjs && pnpm run build:esm",
+    "pack": "pnpm build && pnpm pack",
+    "lint": "eslint --fix .",
+    "prepublishOnly": "npm run lint && npm run build"
+  },
+  "gitHead": "263638b9fd29395dcb64c33dfc2197df47f526af",
+  "devDependencies": {
+    "@streamflow/eslint-config": "7.0.0-alpha.10",
+    "@types/bn.js": "5.1.1",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.30.0",
+    "@coral-xyz/borsh": "^0.29.0",
+    "@solana/buffer-layout": "4.0.1",
+    "@solana/spl-token": "0.3.6",
+    "@solana/wallet-adapter-base": "0.9.19",
+    "@solana/web3.js": "1.70.1",
+    "@streamflow/common": "7.0.0-alpha.10",
+    "bn.js": "5.2.1",
+    "borsh": "^2.0.0",
+    "bs58": "5.0.0",
+    "p-queue": "^8.0.1"
+  }
+}