@streamflow/staking 7.5.3 → 8.0.0-alpha.p287.25d0c28

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

@@ -1,152 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-// eslint-disable-next-line no-restricted-imports
-import BN from "bn.js";
-import { getBN, getNumberFromBN } from "@streamflow/common";
-import { REWARD_AMOUNT_DECIMALS, REWARD_AMOUNT_PRECISION_FACTOR_BN, SCALE_PRECISION_FACTOR_BN } from "../constants.js";
-export class RewardEntryAccumulator {
-    lastAccountedTs;
-    claimedAmount;
-    accountedAmount;
-    rewardPool;
-    stakeEntry;
-    createdTs;
-    lastRewardAmount;
-    lastRewardPeriod;
-    buffer;
-    constructor(lastAccountedTs, claimedAmount, accountedAmount, rewardPool, stakeEntry, createdTs, lastRewardAmount, lastRewardPeriod, buffer) {
-        this.lastAccountedTs = lastAccountedTs;
-        this.claimedAmount = claimedAmount;
-        this.accountedAmount = accountedAmount;
-        this.rewardPool = rewardPool;
-        this.stakeEntry = stakeEntry;
-        this.createdTs = createdTs;
-        this.buffer = buffer;
-        this.lastRewardAmount = lastRewardAmount;
-        this.lastRewardPeriod = lastRewardPeriod;
-    }
-    static fromEntry(entry) {
-        return new this(entry.lastAccountedTs, entry.claimedAmount, entry.accountedAmount, entry.rewardPool, entry.stakeEntry, entry.createdTs, entry.lastRewardAmount, entry.lastRewardPeriod, entry.buffer);
-    }
-    // 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);
-        return claimablePerEffectiveStake.mul(effectiveStakedAmount).div(SCALE_PRECISION_FACTOR_BN);
-    }
-    // Calculates claimable amount from accountable amount.
-    getClaimableAmount() {
-        const claimedAmount = this.claimedAmount.mul(REWARD_AMOUNT_PRECISION_FACTOR_BN);
-        const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
-        return nonClaimedAmount.div(REWARD_AMOUNT_PRECISION_FACTOR_BN);
-    }
-    // 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);
-        return lastAccountedTs.add(periodsToSeconds);
-    }
-    // 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 = RewardEntryAccumulator.fromEntry(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();
-};
-export const calculateRewardRateFromAmount = (rewardAmount, stakeTokenDecimals, rewardTokenDecimals) => {
-    const decimals = rewardTokenDecimals + (REWARD_AMOUNT_DECIMALS - stakeTokenDecimals);
-    return getNumberFromBN(rewardAmount, decimals);
-};
-export const calculateRewardAmountFromValue = (rewardTokenValue, stakeTokenDecimals) => {
-    const decimalsDiff = REWARD_AMOUNT_DECIMALS - stakeTokenDecimals;
-    if (decimalsDiff === 0) {
-        return rewardTokenValue;
-    }
-    const diffFactor = new BN(10).pow(new BN(Math.abs(decimalsDiff)));
-    if (decimalsDiff > 0) {
-        return rewardTokenValue.mul(diffFactor);
-    }
-    return rewardTokenValue.div(diffFactor);
-};
-export const calculateRewardAmountFromRate = (rewardRate, stakeTokenDecimals, rewardTokenDecimals) => {
-    return calculateRewardAmountFromValue(getBN(rewardRate, rewardTokenDecimals), stakeTokenDecimals);
-};

package/dist/esm/solana/lib/stake-weight.d.ts

@@ -1,2 +0,0 @@
-import BN from "bn.js";
-export declare const calculateStakeWeight: (minDuration: BN, maxDuration: BN, maxWeight: BN, duration: BN) => BN;

package/dist/esm/solana/lib/stake-weight.js

@@ -1,12 +0,0 @@
-import BN from "bn.js";
-import { SCALE_PRECISION_FACTOR_BN } 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);
-};

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

@@ -1,77 +0,0 @@
-import { Address, type IdlAccounts } 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 = IdlAccounts<StakePoolIDL>["stakePool"];
-export type StakeEntry = IdlAccounts<StakePoolIDL>["stakeEntry"];
-export type RewardEntry = IdlAccounts<RewardPoolIDL>["rewardEntry"];
-export type RewardPool = IdlAccounts<RewardPoolIDL>["rewardPool"];
-export type FeeValue = IdlAccounts<FeeManagerIDL>["feeValue"];
-export type DefaultFeeValueConfig = IdlAccounts<FeeManagerIDL>["config"];
-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;
-    rewardMint: Address;
-}
-export interface CreateRewardPoolArgs extends BaseStakePoolArgs, TokenProgram {
-    stakePoolNonce: number;
-    rewardMint: Address;
-    nonce: number;
-    rewardAmount: BN;
-    rewardPeriod: BN;
-    permissionless: boolean;
-    lastClaimPeriodOpt: BN | null;
-}
-export interface UpdateRewardPoolArgs {
-    stakePool: Address;
-    rewardAmount: BN | null;
-    rewardPeriod: BN | null;
-    rewardPool: Address;
-}
-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;
-    freezeStakeMint?: boolean | null;
-    unstakePeriod?: BN | null;
-    authority?: Keypair;
-}
-export {};

package/dist/esm/solana/types.js

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