@streamflow/staking 7.0.0-alpha.9 → 7.0.0

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

@@ -3,24 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcRewards = exports.RewardEntryAccumulator = exports.REWARD_AMOUNT_PRECISION_FACTOR = void 0;
+exports.calculateRewardAmountFromRate = exports.calculateRewardAmountFromValue = exports.calculateRewardRateFromAmount = exports.calcRewards = exports.RewardEntryAccumulator = void 0;
 const web3_js_1 = require("@solana/web3.js");
 // eslint-disable-next-line no-restricted-imports
 const bn_js_1 = __importDefault(require("bn.js"));
+const common_1 = require("@streamflow/common");
 const constants_js_1 = require("../constants.js");
-exports.REWARD_AMOUNT_PRECISION_FACTOR = new bn_js_1.default("1000000000");
 class RewardEntryAccumulator {
-    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;
+    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) {
@@ -31,15 +33,13 @@ class RewardEntryAccumulator {
         }
         const periodsPassed = secondsPassed.div(rewardPeriod);
         const claimablePerEffectiveStake = periodsPassed.mul(rewardAmount);
-        const accountableAmount = claimablePerEffectiveStake.mul(effectiveStakedAmount).div(constants_js_1.SCALE_PRECISION_FACTOR_BN);
-        return accountableAmount;
+        return claimablePerEffectiveStake.mul(effectiveStakedAmount).div(constants_js_1.SCALE_PRECISION_FACTOR_BN);
     }
     // Calculates claimable amount from accountable amount.
     getClaimableAmount() {
-        const claimedAmount = this.claimedAmount.mul(exports.REWARD_AMOUNT_PRECISION_FACTOR);
+        const claimedAmount = this.claimedAmount.mul(constants_js_1.REWARD_AMOUNT_PRECISION_FACTOR_BN);
         const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
-        const claimableAmount = nonClaimedAmount.div(exports.REWARD_AMOUNT_PRECISION_FACTOR);
-        return claimableAmount;
+        return nonClaimedAmount.div(constants_js_1.REWARD_AMOUNT_PRECISION_FACTOR_BN);
     }
     // Get the time of the last unlock
     getLastAccountedTs(stakedTs, claimableTs, rewardPeriod) {
@@ -47,8 +47,7 @@ class RewardEntryAccumulator {
         const totalSecondsPassed = claimableTs.sub(lastAccountedTs);
         const periodsPassed = totalSecondsPassed.div(rewardPeriod);
         const periodsToSeconds = periodsPassed.mul(rewardPeriod);
-        const currClaimTs = lastAccountedTs.add(periodsToSeconds);
-        return currClaimTs;
+        return lastAccountedTs.add(periodsToSeconds);
     }
     // Adds accounted amount
     addAccountedAmount(accountedAmount) {
@@ -77,7 +76,7 @@ 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);
+    const rewardEntryAccumulator = RewardEntryAccumulator.fromEntry(rewardEntry);
     if (rewardEntryAccumulator.createdTs.lt(stakeEntry.createdTs)) {
         throw new Error("InvalidRewardEntry");
     }
@@ -132,3 +131,24 @@ const calcRewards = (rewardEntryAccount, stakeEntryAccount, rewardPoolAccount) =
     return rewardEntryAccumulator.getClaimableAmount();
 };
 exports.calcRewards = calcRewards;
+const calculateRewardRateFromAmount = (rewardAmount, stakeTokenDecimals, rewardTokenDecimals) => {
+    const decimals = rewardTokenDecimals + (constants_js_1.REWARD_AMOUNT_DECIMALS - stakeTokenDecimals);
+    return (0, common_1.getNumberFromBN)(rewardAmount, decimals);
+};
+exports.calculateRewardRateFromAmount = calculateRewardRateFromAmount;
+const calculateRewardAmountFromValue = (rewardTokenValue, stakeTokenDecimals) => {
+    const decimalsDiff = constants_js_1.REWARD_AMOUNT_DECIMALS - stakeTokenDecimals;
+    if (decimalsDiff === 0) {
+        return rewardTokenValue;
+    }
+    const diffFactor = new bn_js_1.default(10).pow(new bn_js_1.default(Math.abs(decimalsDiff)));
+    if (decimalsDiff > 0) {
+        return rewardTokenValue.mul(diffFactor);
+    }
+    return rewardTokenValue.div(diffFactor);
+};
+exports.calculateRewardAmountFromValue = calculateRewardAmountFromValue;
+const calculateRewardAmountFromRate = (rewardRate, stakeTokenDecimals, rewardTokenDecimals) => {
+    return (0, exports.calculateRewardAmountFromValue)((0, common_1.getBN)(rewardRate, rewardTokenDecimals), stakeTokenDecimals);
+};
+exports.calculateRewardAmountFromRate = calculateRewardAmountFromRate;

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateStakeWeight = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+const constants_js_1 = require("../constants.js");
+const calculateStakeWeight = (minDuration, maxDuration, maxWeight, duration) => {
+    const durationSpan = maxDuration.sub(minDuration);
+    if (durationSpan.eq(new bn_js_1.default(0))) {
+        return constants_js_1.SCALE_PRECISION_FACTOR_BN;
+    }
+    const durationExceedingMin = duration.sub(minDuration);
+    const normalizedWeight = durationExceedingMin.mul(constants_js_1.SCALE_PRECISION_FACTOR_BN).div(durationSpan);
+    const weightDiff = maxWeight.sub(constants_js_1.SCALE_PRECISION_FACTOR_BN);
+    return bn_js_1.default.max(constants_js_1.SCALE_PRECISION_FACTOR_BN.add(normalizedWeight.mul(weightDiff).div(constants_js_1.SCALE_PRECISION_FACTOR_BN)), constants_js_1.SCALE_PRECISION_FACTOR_BN);
+};
+exports.calculateStakeWeight = calculateStakeWeight;

package/dist/esm/__tests__/solana/rewards.spec.d.ts

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

package/dist/esm/__tests__/solana/rewards.spec.js

@@ -0,0 +1,56 @@
+import { getBN } from "@streamflow/common";
+import { PublicKey } from "@solana/web3.js";
+// eslint-disable-next-line no-restricted-imports
+import BN from "bn.js";
+import { describe, expect, test } from "vitest";
+import { RewardEntryAccumulator, calculateRewardAmountFromRate, calculateRewardRateFromAmount, } from "../../solana/lib/rewards.js";
+import { SCALE_PRECISION_FACTOR_BN } from "../../solana/constants.js";
+const populateRewardEntry = (effectiveStakedAmount, rewardAmount, rewardPeriod, periods) => {
+    const rewardEntry = new RewardEntryAccumulator(new BN(0), new BN(0), new BN(0), PublicKey.default, PublicKey.default, new BN(0), new BN(0), new BN(0), []);
+    if (effectiveStakedAmount && rewardAmount && rewardPeriod) {
+        rewardEntry.accountedAmount = rewardEntry.getAccountableAmount(new BN(0), rewardPeriod.muln(periods || 1), effectiveStakedAmount, rewardAmount, rewardPeriod);
+    }
+    return rewardEntry;
+};
+describe("RewardEntryAccumulator", () => {
+    describe("getClaimableAmount", () => {
+        const testCases = [
+            [9, 9, 1, 0.0025, new BN(2_500_000)],
+            [6, 9, 1, 0.0025, new BN(2_500_000_000)],
+            [9, 6, 1, 0.0025, new BN(2_500)],
+            [1, 8, 1, 0.0025, new BN(25_000_000_000_000)],
+        ];
+        testCases.forEach(([stakeTokenDecimals, rewardTokenDecimals, periods, rewardRate, expectedRewardAmount]) => {
+            test(`test decimals - ${stakeTokenDecimals}/${rewardTokenDecimals}/${periods}/${rewardRate}`, () => {
+                const stakedAmount = getBN(1, stakeTokenDecimals);
+                const effectiveStakedAmount = stakedAmount.mul(SCALE_PRECISION_FACTOR_BN);
+                const rewardPeriod = new BN(1);
+                const rewardAmount = calculateRewardAmountFromRate(rewardRate, stakeTokenDecimals, rewardTokenDecimals);
+                const rewardEntry = populateRewardEntry(effectiveStakedAmount, rewardAmount, rewardPeriod, periods);
+                const claimableAmount = rewardEntry.getClaimableAmount();
+                expect(rewardAmount.toString()).toEqual(expectedRewardAmount.toString());
+                expect(claimableAmount.toString()).toEqual(getBN(rewardRate, rewardTokenDecimals).muln(periods).toString());
+                expect(calculateRewardRateFromAmount(rewardAmount, stakeTokenDecimals, rewardTokenDecimals)).toEqual(rewardRate);
+            });
+        });
+        test(`test decimals - negative difference`, () => {
+            let rewardAmount = calculateRewardAmountFromRate(0.0025, 18, 1);
+            expect(rewardAmount.toString()).toEqual(new BN(0).toString());
+            rewardAmount = calculateRewardAmountFromRate(0.0025, 12, 4);
+            expect(rewardAmount.toString()).toEqual(new BN(0).toString());
+        });
+        test(`test decimals - precision loss`, () => {
+            const stakeTokenDecimals = 12;
+            const rewardTokenDecimals = 6;
+            const stakedAmount = getBN(1, stakeTokenDecimals);
+            const effectiveStakedAmount = stakedAmount.mul(SCALE_PRECISION_FACTOR_BN);
+            const rewardPeriod = new BN(1);
+            const rewardAmount = calculateRewardAmountFromRate(0.0025, stakeTokenDecimals, rewardTokenDecimals);
+            const rewardEntry = populateRewardEntry(effectiveStakedAmount, rewardAmount, rewardPeriod);
+            const claimableAmount = rewardEntry.getClaimableAmount();
+            expect(rewardAmount.toString()).toEqual(new BN(2).toString());
+            expect(claimableAmount.toString()).toEqual(getBN(0.002, rewardTokenDecimals).toString());
+            expect(calculateRewardRateFromAmount(rewardAmount, stakeTokenDecimals, rewardTokenDecimals)).toEqual(0.002);
+        });
+    });
+});

package/dist/esm/index.d.ts

@@ -1,6 +1,7 @@
-export { default as SolanaStakingClient } from "./solana/client.js";
-export * from "./solana/utils.js";
+export { SolanaStakingClient } from "./solana/client.js";
 export * from "./solana/types.js";
 export * from "./solana/lib/derive-accounts.js";
 export * from "./solana/lib/rewards.js";
+export * from "./solana/lib/fee-amounts.js";
+export * from "./solana/lib/stake-weight.js";
 export * as constants from "./solana/constants.js";

package/dist/esm/index.js

@@ -1,6 +1,7 @@
-export { default as SolanaStakingClient } from "./solana/client.js";
-export * from "./solana/utils.js";
+export { SolanaStakingClient } from "./solana/client.js";
 export * from "./solana/types.js";
 export * from "./solana/lib/derive-accounts.js";
 export * from "./solana/lib/rewards.js";
+export * from "./solana/lib/fee-amounts.js";
+export * from "./solana/lib/stake-weight.js";
 export * as constants from "./solana/constants.js";

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

@@ -1,4 +1,4 @@
-import { Program, ProgramAccount } from "@coral-xyz/anchor";
+import { AccountsCoder, Idl, IdlTypes, Program, ProgramAccount } from "@coral-xyz/anchor";
 import { Commitment, Connection, ConnectionConfig, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { ICluster, ITransactionResult } from "@streamflow/common";
 import PQueue from "p-queue";
@@ -6,7 +6,7 @@ import { REWARD_ENTRY_BYTE_OFFSETS, STAKE_ENTRY_BYTE_OFFSETS, STAKE_POOL_BYTE_OF
 import { FeeManager as FeeManagerProgramType } from "./descriptor/fee_manager.js";
 import { RewardPool as RewardPoolProgramType } from "./descriptor/reward_pool.js";
 import { StakePool as StakePoolProgramType } from "./descriptor/stake_pool.js";
-import { ClaimRewardPoolArgs, CreateRewardEntryArgs, CreateRewardPoolArgs, CreateStakePoolArgs, FeeValue, FundPoolArgs, IInteractSolanaExt, RewardEntry, RewardPool, StakeArgs, StakeEntry, StakePool, UnstakeArgs } from "./types.js";
+import { ClaimRewardPoolArgs, CreateRewardEntryArgs, CreateRewardPoolArgs, CreateStakePoolArgs, DefaultFeeValueConfig, FeeValue, FundPoolArgs, IInteractSolanaExt, RewardEntry, RewardPool, StakeArgs, StakeEntry, StakePool, UnstakeArgs, UpdateRewardPoolArgs } from "./types.js";
 interface Programs {
     stakePoolProgram: Program<StakePoolProgramType>;
     rewardPoolProgram: Program<RewardPoolProgramType>;
@@ -27,7 +27,7 @@ interface IInitOptions {
     sendRate?: number;
     sendThrottler?: PQueue;
 }
-export default class SolanaStakingClient {
+export declare class SolanaStakingClient {
     connection: Connection;
     private commitment;
     private sendThrottler;
@@ -41,6 +41,8 @@ export default class SolanaStakingClient {
     searchStakeEntries(criteria?: Partial<Pick<StakeEntry, keyof typeof STAKE_ENTRY_BYTE_OFFSETS>>): Promise<ProgramAccount<StakeEntry>[]>;
     searchRewardPools(criteria?: Partial<Pick<RewardPool, "stakePool" | "mint">>): Promise<ProgramAccount<RewardPool>[]>;
     searchRewardEntries(criteria: Partial<Pick<RewardEntry, keyof typeof REWARD_ENTRY_BYTE_OFFSETS>>): Promise<ProgramAccount<RewardEntry>[]>;
+    getFee(target: string | PublicKey): Promise<FeeValue | DefaultFeeValueConfig>;
+    getDefaultFeeValue(): Promise<DefaultFeeValueConfig>;
     getFeeValueIfExists(target: string | PublicKey): Promise<FeeValue | null>;
     createStakePool(data: CreateStakePoolArgs, extParams: IInteractSolanaExt): Promise<CreationResult>;
     prepareCreateStakePoolInstructions({ maxWeight, maxDuration, minDuration, mint, permissionless, nonce, tokenProgramId, }: CreateStakePoolArgs, extParams: IInteractSolanaExt): Promise<{
@@ -72,6 +74,15 @@ export default class SolanaStakingClient {
     prepareCreateRewardEntryInstructions({ stakePoolMint, stakePool, rewardPoolNonce, depositNonce }: CreateRewardEntryArgs, extParams: IInteractSolanaExt): Promise<{
         ixs: TransactionInstruction[];
     }>;
+    updateRewardPool(data: UpdateRewardPoolArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+        txId: string;
+    }>;
+    prepareUpdateRewardPoolInstructions({ rewardPool, rewardAmount, rewardPeriod }: UpdateRewardPoolArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    decode<ProgramName extends keyof Programs = keyof Programs, DecodingProgram = Programs[ProgramName], DerivedIdl extends Idl = DecodingProgram extends Program<infer IDLType> ? IDLType : never, AccountName extends keyof IdlTypes<DerivedIdl> = keyof IdlTypes<DerivedIdl>, DecodedAccount = IdlTypes<DerivedIdl>[AccountName]>(programKey: ProgramName, accountName: AccountName, accInfo: Parameters<AccountsCoder["decode"]>[1]): DecodedAccount;
+    getDiscriminator<ProgramName extends keyof Programs = keyof Programs, DecodingProgram = Programs[ProgramName], DerivedIdl extends Idl = DecodingProgram extends Program<infer IDLType> ? IDLType : never, AccountName extends keyof IdlTypes<DerivedIdl> = keyof IdlTypes<DerivedIdl>>(programKey: ProgramName, accountName: AccountName): number[];
     private execute;
 }
 export {};

package/dist/esm/solana/client.js

@@ -1,14 +1,14 @@
 import { Program, parseIdlErrors, translateError, } from "@coral-xyz/anchor";
 import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token";
-import { Connection, PublicKey, } from "@solana/web3.js";
-import { ContractError, ICluster } from "@streamflow/common";
-import { buildSendThrottler, checkOrCreateAtaBatch, prepareTransaction, signAndExecuteTransaction, } from "@streamflow/common/solana";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { ContractError, ICluster, invariant } from "@streamflow/common";
+import { buildSendThrottler, checkOrCreateAtaBatch, getFilters, pk, prepareTransaction, signAndExecuteTransaction, } from "@streamflow/common/solana";
 import { REWARD_ENTRY_BYTE_OFFSETS, REWARD_POOL_BYTE_OFFSETS, REWARD_POOL_PROGRAM_ID, STAKE_ENTRY_BYTE_OFFSETS, STAKE_POOL_BYTE_OFFSETS, STAKE_POOL_PROGRAM_ID, STREAMFLOW_TREASURY_PUBLIC_KEY, } from "./constants.js";
 import FeeManagerIDL from "./descriptor/idl/fee_manager.json";
 import RewardPoolIDL from "./descriptor/idl/reward_pool.json";
 import StakePoolIDL from "./descriptor/idl/stake_pool.json";
-import { deriveFeeValuePDA, deriveRewardPoolPDA, deriveRewardVaultPDA, deriveStakeEntryPDA, deriveStakeMintPDA, deriveStakePoolPDA, } from "./lib/derive-accounts.js";
-export default class SolanaStakingClient {
+import { deriveConfigPDA, deriveFeeValuePDA, deriveRewardPoolPDA, deriveRewardVaultPDA, deriveStakeEntryPDA, deriveStakeMintPDA, deriveStakePoolPDA, } from "./lib/derive-accounts.js";
+export class SolanaStakingClient {
     connection;
     commitment;
     sendThrottler;
@@ -73,6 +73,18 @@ export default class SolanaStakingClient {
         const { rewardPoolProgram } = this.programs;
         return rewardPoolProgram.account.rewardEntry.all(getFilters(criteria, REWARD_ENTRY_BYTE_OFFSETS));
     }
+    async getFee(target) {
+        const perTargetFee = await this.getFeeValueIfExists(target);
+        if (perTargetFee) {
+            return perTargetFee;
+        }
+        return this.getDefaultFeeValue();
+    }
+    getDefaultFeeValue() {
+        const { feeManagerProgram } = this.programs;
+        const feeValueKey = deriveConfigPDA(feeManagerProgram.programId);
+        return feeManagerProgram.account.config.fetch(feeValueKey);
+    }
     getFeeValueIfExists(target) {
         const { feeManagerProgram } = this.programs;
         const feeValueKey = deriveFeeValuePDA(feeManagerProgram.programId, new PublicKey(target));
@@ -263,6 +275,39 @@ export default class SolanaStakingClient {
             .instruction();
         return { ixs: [instruction] };
     }
+    async updateRewardPool(data, extParams) {
+        const { ixs } = await this.prepareUpdateRewardPoolInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareUpdateRewardPoolInstructions({ rewardPool, rewardAmount, rewardPeriod }, extParams) {
+        const { rewardPoolProgram } = this.programs;
+        const invoker = extParams.invoker.publicKey;
+        invariant(invoker, "Undefined invoker publicKey");
+        const instruction = await rewardPoolProgram.methods
+            .updatePool(rewardAmount, rewardPeriod)
+            .accountsPartial({
+            authority: invoker,
+            rewardPool,
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    decode(programKey, accountName, accInfo) {
+        const decodingProgram = this.programs[programKey];
+        invariant(decodingProgram, `Decoding program with key ${programKey} is not available`);
+        return decodingProgram.coder.accounts.decode(accountName.toString(), accInfo);
+    }
+    getDiscriminator(programKey, accountName) {
+        const decodingProgram = this.programs[programKey];
+        invariant(decodingProgram, `Decoding program with key ${programKey} is not available`);
+        const accountEntity = decodingProgram.idl.accounts.find((acc) => acc.name === accountName);
+        invariant(accountEntity, `Decoding program with key ${programKey} doesn't specify account with name ${accountName.toString()}`);
+        return accountEntity.discriminator;
+    }
     async execute(ixs, extParams) {
         const { tx, hash, context } = await prepareTransaction(this.connection, ixs, extParams.invoker.publicKey);
         try {
@@ -284,30 +329,3 @@ export default class SolanaStakingClient {
         }
     }
 }
-function pk(address) {
-    return typeof address === "string" ? new PublicKey(address) : address;
-}
-const prefix = "Assertion failed";
-function invariant(condition, message) {
-    if (condition) {
-        return;
-    }
-    const provided = typeof message === "function" ? message() : message;
-    const value = provided ? `${prefix}: ${provided}` : prefix;
-    throw new Error(value);
-}
-function getFilters(criteria, byteOffsets) {
-    return Object.entries(criteria).reduce((acc, [key, value]) => {
-        const criteriaKey = key;
-        const effectiveByteOffset = byteOffsets[criteriaKey];
-        if (criteria[criteriaKey] && effectiveByteOffset) {
-            acc.push({
-                memcmp: {
-                    offset: effectiveByteOffset,
-                    bytes: value.toString(),
-                },
-            });
-        }
-        return acc;
-    }, []);
-}

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

@@ -1,14 +1,15 @@
-/// <reference types="bn.js" />
-/// <reference types="node" />
 import { BN } from "@coral-xyz/anchor";
 import { ICluster } from "@streamflow/common";
 import { PublicKey } from "@solana/web3.js";
 export declare const FEE_PRECISION_FACTOR = 10000;
 export declare const FEE_PRECISION_FACTOR_BN: BN;
-export declare const DEFAULT_FEE = 99;
+export declare const DEFAULT_FEE = 19;
 export declare const DEFAULT_FEE_BN: BN;
 export declare const SCALE_PRECISION_FACTOR = 1000000000;
 export declare const SCALE_PRECISION_FACTOR_BN: BN;
+export declare const REWARD_AMOUNT_DECIMALS = 9;
+export declare const REWARD_AMOUNT_PRECISION_FACTOR = 1000000000;
+export declare const REWARD_AMOUNT_PRECISION_FACTOR_BN: BN;
 export declare const U64_MAX = 18446744073709551615n;
 export declare const STAKE_ENTRY_DISCRIMINATOR: number[];
 export declare const STAKE_ENTRY_PREFIX: Buffer;
@@ -48,3 +49,4 @@ export declare const REWARD_ENTRY_BYTE_OFFSETS: {
 };
 export declare const STAKE_POOL_PROGRAM_ID: Record<ICluster, string>;
 export declare const REWARD_POOL_PROGRAM_ID: Record<ICluster, string>;
+export declare const FEE_PROGRAM_ID: Record<ICluster, string>;

package/dist/esm/solana/constants.js

@@ -1,12 +1,15 @@
 import { BN } from "@coral-xyz/anchor";
 import { ICluster } from "@streamflow/common";
 import { PublicKey } from "@solana/web3.js";
-export const FEE_PRECISION_FACTOR = 10000;
+export const FEE_PRECISION_FACTOR = 10_000;
 export const FEE_PRECISION_FACTOR_BN = new BN(FEE_PRECISION_FACTOR);
-export const DEFAULT_FEE = 99;
+export const DEFAULT_FEE = 19;
 export const DEFAULT_FEE_BN = new BN(DEFAULT_FEE);
-export const SCALE_PRECISION_FACTOR = 1000000000;
+export const SCALE_PRECISION_FACTOR = 1_000_000_000;
 export const SCALE_PRECISION_FACTOR_BN = new BN(SCALE_PRECISION_FACTOR);
+export const REWARD_AMOUNT_DECIMALS = 9;
+export const REWARD_AMOUNT_PRECISION_FACTOR = 1_000_000_000;
+export const REWARD_AMOUNT_PRECISION_FACTOR_BN = new BN(REWARD_AMOUNT_PRECISION_FACTOR);
 export const U64_MAX = 18446744073709551615n;
 export const STAKE_ENTRY_DISCRIMINATOR = [187, 127, 9, 35, 155, 68, 86, 40];
 export const STAKE_ENTRY_PREFIX = Buffer.from("stake-entry", "utf-8");
@@ -26,7 +29,7 @@ export const STAKE_ENTRY_BYTE_OFFSETS = {
     payer: STAKE_ENTRY_OWNER_OFFSET,
     stakePool: STAKE_ENTRY_STAKE_POOL_OFFSET,
 };
-export const STAKE_POOL_MINT_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 8;
+export const STAKE_POOL_MINT_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 2;
 export const STAKE_POOL_CREATOR_OFFSET = STAKE_POOL_MINT_OFFSET + 32;
 export const STAKE_POOL_BYTE_OFFSETS = {
     mint: STAKE_POOL_MINT_OFFSET,
@@ -56,3 +59,9 @@ export const REWARD_POOL_PROGRAM_ID = {
     [ICluster.Testnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
     [ICluster.Local]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
 };
+export const FEE_PROGRAM_ID = {
+    [ICluster.Mainnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+    [ICluster.Devnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+    [ICluster.Testnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+    [ICluster.Local]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+};

package/dist/esm/solana/descriptor/idl/reward_pool.json

@@ -338,8 +338,8 @@
                         "program": {
                             "kind": "const",
                             "value": [
-                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218,
-                                255, 16, 132, 4, 142, 123, 216, 219, 233, 248, 89
+                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218, 255, 16,
+                                132, 4, 142, 123, 216, 219, 233, 248, 89
                             ]
                         }
                     }
@@ -778,9 +778,7 @@
                     },
                     {
                         "name": "effective_amount",
-                        "docs": [
-                            "Effective Amount staked, does not equal to deposited amount, accounts for Stake Weight"
-                        ],
+                        "docs": ["Effective Amount staked, does not equal to deposited amount, accounts for Stake Weight"],
                         "type": "u128"
                     },
                     {