@streamflow/staking 7.0.0-alpha.10

package/dist/cjs/solana/descriptor/reward_pool.js

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

package/dist/cjs/solana/descriptor/stake_pool.js

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

package/dist/cjs/solana/lib/derive-accounts.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveFeeValuePDA = exports.deriveConfigPDA = exports.deriveRewardEntryPDA = exports.deriveRewardVaultPDA = exports.deriveRewardPoolPDA = exports.deriveStakeEntryPDA = exports.deriveStakeMintPDA = exports.deriveStakeVaultPDA = exports.deriveStakePoolPDA = 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 constants_js_1 = require("../constants.js");
+const deriveStakePoolPDA = (programId, mint, authority, nonce) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.STAKE_POOL_PREFIX, mint.toBuffer(), authority.toBuffer(), new bn_js_1.default(nonce).toArrayLike(Buffer, "le", 1)], programId)[0];
+};
+exports.deriveStakePoolPDA = deriveStakePoolPDA;
+const deriveStakeVaultPDA = (programId, stakePool) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.STAKE_VAULT_PREFIX, stakePool.toBuffer()], programId)[0];
+};
+exports.deriveStakeVaultPDA = deriveStakeVaultPDA;
+const deriveStakeMintPDA = (programId, stakePool) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.STAKE_MINT_PREFIX, stakePool.toBuffer()], programId)[0];
+};
+exports.deriveStakeMintPDA = deriveStakeMintPDA;
+const deriveStakeEntryPDA = (programId, stakePool, authority, nonce) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.STAKE_ENTRY_PREFIX, stakePool.toBuffer(), authority.toBuffer(), new bn_js_1.default(nonce).toArrayLike(Buffer, "le", 4)], programId)[0];
+};
+exports.deriveStakeEntryPDA = deriveStakeEntryPDA;
+const deriveRewardPoolPDA = (programId, stakePool, mint, nonce) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.REWARD_POOL_PREFIX, stakePool.toBuffer(), mint.toBuffer(), new bn_js_1.default(nonce).toArrayLike(Buffer, "le", 1)], programId)[0];
+};
+exports.deriveRewardPoolPDA = deriveRewardPoolPDA;
+const deriveRewardVaultPDA = (programId, rewardPool) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.REWARD_VAULT_PREFIX, rewardPool.toBuffer()], programId)[0];
+};
+exports.deriveRewardVaultPDA = deriveRewardVaultPDA;
+const deriveRewardEntryPDA = (programId, rewardPool, stakeEntry) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.REWARD_ENTRY_PREFIX, rewardPool.toBuffer(), stakeEntry.toBuffer()], programId)[0];
+};
+exports.deriveRewardEntryPDA = deriveRewardEntryPDA;
+const deriveConfigPDA = (programId) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.CONFIG_PREFIX], programId)[0];
+};
+exports.deriveConfigPDA = deriveConfigPDA;
+const deriveFeeValuePDA = (programId, target) => {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.FEE_VALUE_PREFIX, target.toBuffer()], programId)[0];
+};
+exports.deriveFeeValuePDA = deriveFeeValuePDA;

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

@@ -0,0 +1,134 @@
+"use strict";
+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;
+const web3_js_1 = require("@solana/web3.js");
+// eslint-disable-next-line no-restricted-imports
+const bn_js_1 = __importDefault(require("bn.js"));
+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;
+    }
+    // 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_js_1.default(0)) ? this.lastAccountedTs : stakedTs;
+        const secondsPassed = accountableTs.sub(lastAccountedTs);
+        if (secondsPassed.lt(rewardPeriod)) {
+            return new bn_js_1.default(0);
+        }
+        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;
+    }
+    // Calculates claimable amount from accountable amount.
+    getClaimableAmount() {
+        const claimedAmount = this.claimedAmount.mul(exports.REWARD_AMOUNT_PRECISION_FACTOR);
+        const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
+        const claimableAmount = nonClaimedAmount.div(exports.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);
+    }
+}
+exports.RewardEntryAccumulator = RewardEntryAccumulator;
+const createDefaultRewardEntry = (stakeEntry, rewardPool) => {
+    return {
+        stakeEntry: new web3_js_1.PublicKey(stakeEntry.publicKey),
+        rewardPool: new web3_js_1.PublicKey(rewardPool.publicKey),
+        createdTs: stakeEntry.account.createdTs,
+        lastAccountedTs: new bn_js_1.default(0),
+        lastRewardAmount: new bn_js_1.default(0),
+        lastRewardPeriod: new bn_js_1.default(0),
+        accountedAmount: new bn_js_1.default(0),
+        claimedAmount: new bn_js_1.default(0),
+        buffer: [],
+    };
+};
+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_js_1.default.max(stakeEntry.createdTs, rewardPool.createdTs) : stakeEntry.createdTs;
+    const claimableTs = stakeEntry.closedTs.gtn(0) ? stakeEntry.closedTs : new bn_js_1.default(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_js_1.default(0);
+            secondUpdateTs = rewardPool.lastAmountUpdateTs;
+            rewardAmount = rewardEntryAccumulator.lastRewardAmount;
+            rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
+        }
+        else {
+            firstUpdateTs = new bn_js_1.default(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();
+};
+exports.calcRewards = calcRewards;

package/dist/cjs/solana/types.js

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

package/dist/cjs/solana/utils.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAmountWithTransferFees = exports.divCeilN = exports.calculateDecimalsShift = exports.calculateFeeAmount = exports.calculateStakeWeight = void 0;
+// eslint-disable-next-line no-restricted-imports
+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;
+const calculateFeeAmount = (amount, fee = constants_js_1.DEFAULT_FEE_BN) => {
+    if (fee.eq(constants_js_1.FEE_PRECISION_FACTOR_BN)) {
+        return amount;
+    }
+    return amount.mul(fee).div(constants_js_1.FEE_PRECISION_FACTOR_BN);
+};
+exports.calculateFeeAmount = calculateFeeAmount;
+const calculateDecimalsShift = (maxWeight, maxShift = 999) => {
+    if (maxShift == 0) {
+        return 0;
+    }
+    let decimalsShift = 0;
+    while ((maxWeight * constants_js_1.U64_MAX) / BigInt(constants_js_1.SCALE_PRECISION_FACTOR) / BigInt(10 ** decimalsShift) > constants_js_1.U64_MAX) {
+        decimalsShift += 1;
+        if (decimalsShift == maxShift) {
+            return maxShift;
+        }
+    }
+    return decimalsShift;
+};
+exports.calculateDecimalsShift = calculateDecimalsShift;
+const divCeilN = (n, d) => n / d + (n % d ? BigInt(1) : BigInt(0));
+exports.divCeilN = divCeilN;
+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 = (0, exports.divCeilN)(numerator, denominator);
+        const fee = rawPreFeeAmount - transferAmount;
+        transferAmount = rawPreFeeAmount;
+        feeCharged = fee > transferFee.maximumFee ? transferFee.maximumFee : fee;
+    }
+    return { transferAmount, feeCharged };
+}
+exports.calculateAmountWithTransferFees = calculateAmountWithTransferFees;

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

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

@@ -0,0 +1,77 @@
+import { 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";
+import { REWARD_ENTRY_BYTE_OFFSETS, STAKE_ENTRY_BYTE_OFFSETS, STAKE_POOL_BYTE_OFFSETS } from "./constants.js";
+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";
+interface Programs {
+    stakePoolProgram: Program<StakePoolProgramType>;
+    rewardPoolProgram: Program<RewardPoolProgramType>;
+    feeManagerProgram: Program<FeeManagerProgramType>;
+}
+type CreationResult = ITransactionResult & {
+    metadataId: PublicKey;
+};
+interface IInitOptions {
+    clusterUrl: string;
+    cluster?: ICluster;
+    commitment?: Commitment | ConnectionConfig;
+    programIds?: {
+        stakePool?: string;
+        rewardPool?: string;
+        feeManager?: string;
+    };
+    sendRate?: number;
+    sendThrottler?: PQueue;
+}
+export default class SolanaStakingClient {
+    connection: Connection;
+    private commitment;
+    private sendThrottler;
+    private programs;
+    constructor({ clusterUrl, cluster, commitment, programIds, sendRate, sendThrottler, }: IInitOptions);
+    getCurrentProgramId(programKey: keyof Programs): PublicKey;
+    getCommitment(): Commitment | undefined;
+    getStakePool(id: string | PublicKey): Promise<StakePool>;
+    searchStakePools(criteria?: Partial<Pick<StakePool, keyof typeof STAKE_POOL_BYTE_OFFSETS>>): Promise<ProgramAccount<StakePool>[]>;
+    getStakeEntry(id: string | PublicKey): Promise<StakeEntry | null>;
+    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>[]>;
+    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<{
+        ixs: TransactionInstruction[];
+        publicKey: PublicKey;
+    }>;
+    stake(data: StakeArgs, extParams: IInteractSolanaExt): Promise<ITransactionResult>;
+    prepareStakeInstructions({ nonce, amount, duration, stakePool, stakePoolMint, tokenProgramId }: StakeArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    unstake(data: UnstakeArgs, extParams: IInteractSolanaExt): Promise<ITransactionResult>;
+    prepareUnstakeInstructions({ stakePool, stakePoolMint, nonce, tokenProgramId }: UnstakeArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    createRewardPool(data: CreateRewardPoolArgs, extParams: IInteractSolanaExt): Promise<CreationResult>;
+    prepareCreateRewardPoolInstructions({ nonce, rewardAmount, rewardPeriod, rewardMint, permissionless, stakePool, tokenProgramId, }: CreateRewardPoolArgs, extParams: IInteractSolanaExt): Promise<{
+        publicKey: PublicKey;
+        ixs: TransactionInstruction[];
+    }>;
+    claimRewards(data: ClaimRewardPoolArgs, extParams: IInteractSolanaExt): Promise<ITransactionResult>;
+    prepareClaimRewardsInstructions({ rewardPoolNonce, depositNonce, stakePool, tokenProgramId, rewardMint }: ClaimRewardPoolArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    fundPool(data: FundPoolArgs, extParams: IInteractSolanaExt): Promise<ITransactionResult>;
+    prepareFundPoolInstructions({ amount, tokenProgramId, rewardMint, stakePool, feeValue, nonce }: FundPoolArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    createRewardEntry(data: CreateRewardEntryArgs, extParams: IInteractSolanaExt): Promise<ITransactionResult>;
+    prepareCreateRewardEntryInstructions({ stakePoolMint, stakePool, rewardPoolNonce, depositNonce }: CreateRewardEntryArgs, extParams: IInteractSolanaExt): Promise<{
+        ixs: TransactionInstruction[];
+    }>;
+    private execute;
+}
+export {};

package/dist/esm/solana/client.js

@@ -0,0 +1,313 @@
+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 { 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 {
+    connection;
+    commitment;
+    sendThrottler;
+    programs;
+    constructor({ clusterUrl, cluster = ICluster.Mainnet, commitment = "confirmed", programIds, sendRate = 1, sendThrottler, }) {
+        this.commitment = commitment;
+        this.connection = new Connection(clusterUrl, this.commitment);
+        this.sendThrottler = sendThrottler ?? buildSendThrottler(sendRate);
+        const stakePoolIdl = {
+            ...StakePoolIDL,
+            address: programIds?.stakePool ?? STAKE_POOL_PROGRAM_ID[cluster] ?? StakePoolIDL.address,
+        };
+        const rewardPoolIdl = {
+            ...RewardPoolIDL,
+            address: programIds?.rewardPool ?? REWARD_POOL_PROGRAM_ID[cluster] ?? RewardPoolIDL.address,
+        };
+        const feeManagerIdl = {
+            ...FeeManagerIDL,
+            address: programIds?.feeManager ?? FeeManagerIDL.address,
+        };
+        this.programs = {
+            stakePoolProgram: new Program(stakePoolIdl, {
+                connection: this.connection,
+            }),
+            rewardPoolProgram: new Program(rewardPoolIdl, {
+                connection: this.connection,
+            }),
+            feeManagerProgram: new Program(feeManagerIdl, {
+                connection: this.connection,
+            }),
+        };
+    }
+    getCurrentProgramId(programKey) {
+        const program = this.programs[programKey];
+        invariant(program, `Program ${programKey} is not found`);
+        return program.programId;
+    }
+    getCommitment() {
+        return typeof this.commitment == "string" ? this.commitment : this.commitment.commitment;
+    }
+    async getStakePool(id) {
+        const { stakePoolProgram } = this.programs;
+        return stakePoolProgram.account.stakePool.fetch(id);
+    }
+    async searchStakePools(criteria = {}) {
+        const { stakePoolProgram } = this.programs;
+        return stakePoolProgram.account.stakePool.all(getFilters(criteria, STAKE_POOL_BYTE_OFFSETS));
+    }
+    async getStakeEntry(id) {
+        const { stakePoolProgram } = this.programs;
+        return stakePoolProgram.account.stakeEntry.fetch(id);
+    }
+    async searchStakeEntries(criteria = {}) {
+        const { stakePoolProgram } = this.programs;
+        return stakePoolProgram.account.stakeEntry.all(getFilters(criteria, STAKE_ENTRY_BYTE_OFFSETS));
+    }
+    async searchRewardPools(criteria = {}) {
+        const { rewardPoolProgram } = this.programs;
+        return rewardPoolProgram.account.rewardPool.all(getFilters(criteria, REWARD_POOL_BYTE_OFFSETS));
+    }
+    async searchRewardEntries(criteria) {
+        const { rewardPoolProgram } = this.programs;
+        return rewardPoolProgram.account.rewardEntry.all(getFilters(criteria, REWARD_ENTRY_BYTE_OFFSETS));
+    }
+    getFeeValueIfExists(target) {
+        const { feeManagerProgram } = this.programs;
+        const feeValueKey = deriveFeeValuePDA(feeManagerProgram.programId, new PublicKey(target));
+        return feeManagerProgram.account.feeValue.fetchNullable(feeValueKey);
+    }
+    async createStakePool(data, extParams) {
+        const { ixs, publicKey } = await this.prepareCreateStakePoolInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+            metadataId: publicKey,
+        };
+    }
+    async prepareCreateStakePoolInstructions({ maxWeight, maxDuration, minDuration, mint, permissionless = false, nonce, tokenProgramId = TOKEN_PROGRAM_ID, }, extParams) {
+        const { stakePoolProgram } = this.programs;
+        const creator = extParams.invoker.publicKey;
+        invariant(creator, "Undefined invoker publicKey");
+        const createInstruction = await stakePoolProgram.methods
+            .createPool(nonce, maxWeight, minDuration, maxDuration, permissionless)
+            .accounts({
+            creator,
+            mint,
+            tokenProgram: tokenProgramId,
+        })
+            .instruction();
+        const stakePoolPDA = deriveStakePoolPDA(stakePoolProgram.programId, pk(mint), creator, nonce);
+        return { ixs: [createInstruction], publicKey: stakePoolPDA };
+    }
+    async stake(data, extParams) {
+        const { ixs } = await this.prepareStakeInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareStakeInstructions({ nonce, amount, duration, stakePool, stakePoolMint, tokenProgramId = TOKEN_PROGRAM_ID }, extParams) {
+        const { stakePoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const mint = deriveStakeMintPDA(stakePoolProgram.programId, pk(stakePool));
+        const stakeMintAccountKey = getAssociatedTokenAddressSync(mint, staker, false, pk(tokenProgramId));
+        const poolMintAccountKey = getAssociatedTokenAddressSync(pk(stakePoolMint), staker, false, pk(tokenProgramId));
+        const instruction = await stakePoolProgram.methods
+            .stake(nonce, amount, duration)
+            .accounts({
+            stakePool: stakePool,
+            tokenProgram: tokenProgramId,
+            from: poolMintAccountKey,
+            to: stakeMintAccountKey,
+            authority: staker,
+            payer: staker,
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    async unstake(data, extParams) {
+        const { ixs } = await this.prepareUnstakeInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareUnstakeInstructions({ stakePool, stakePoolMint, nonce, tokenProgramId = TOKEN_PROGRAM_ID }, extParams) {
+        const { stakePoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const stakeMintKey = deriveStakeMintPDA(stakePoolProgram.programId, pk(stakePool));
+        const stakeEntryKey = deriveStakeEntryPDA(stakePoolProgram.programId, pk(stakePool), staker, nonce);
+        const poolMintAccountKey = getAssociatedTokenAddressSync(pk(stakePoolMint), staker, false, pk(tokenProgramId));
+        const stakeMintAccountKey = getAssociatedTokenAddressSync(stakeMintKey, staker, false, pk(tokenProgramId));
+        const instruction = await stakePoolProgram.methods
+            .unstake()
+            .accounts({
+            stakeEntry: stakeEntryKey,
+            to: poolMintAccountKey,
+            from: stakeMintAccountKey,
+            authority: staker,
+            tokenProgram: tokenProgramId,
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    async createRewardPool(data, extParams) {
+        const { ixs, publicKey } = await this.prepareCreateRewardPoolInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+            metadataId: publicKey,
+        };
+    }
+    async prepareCreateRewardPoolInstructions({ nonce, rewardAmount, rewardPeriod, rewardMint, permissionless = false, stakePool, tokenProgramId = TOKEN_PROGRAM_ID, }, extParams) {
+        const { rewardPoolProgram } = this.programs;
+        const creator = extParams.invoker.publicKey;
+        invariant(creator, "Undefined invoker publicKey");
+        const instruction = await rewardPoolProgram.methods
+            .createPool(nonce, rewardAmount, rewardPeriod, permissionless)
+            .accounts({
+            creator,
+            stakePool,
+            mint: rewardMint,
+            tokenProgram: tokenProgramId,
+        })
+            .instruction();
+        const rewardPoolKey = deriveRewardPoolPDA(rewardPoolProgram.programId, pk(stakePool), pk(rewardMint), nonce);
+        return { publicKey: rewardPoolKey, ixs: [instruction] };
+    }
+    async claimRewards(data, extParams) {
+        const { ixs } = await this.prepareClaimRewardsInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareClaimRewardsInstructions({ rewardPoolNonce, depositNonce, stakePool, tokenProgramId = TOKEN_PROGRAM_ID, rewardMint }, extParams) {
+        const { stakePoolProgram, rewardPoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const instruction = await rewardPoolProgram.methods
+            .claimRewards()
+            .accounts({
+            stakeEntry: deriveStakeEntryPDA(stakePoolProgram.programId, pk(stakePool), staker, depositNonce),
+            rewardPool: deriveRewardPoolPDA(rewardPoolProgram.programId, pk(stakePool), pk(rewardMint), rewardPoolNonce),
+            claimant: staker,
+            tokenProgram: tokenProgramId,
+            to: getAssociatedTokenAddressSync(pk(rewardMint), staker, false, pk(tokenProgramId)),
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    async fundPool(data, extParams) {
+        const { ixs } = await this.prepareFundPoolInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareFundPoolInstructions({ amount, tokenProgramId = TOKEN_PROGRAM_ID, rewardMint, stakePool, feeValue, nonce }, extParams) {
+        const { rewardPoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const existingFee = await this.getFeeValueIfExists(staker);
+        const rewardMintPk = pk(rewardMint);
+        const tokenProgramPk = pk(tokenProgramId);
+        const treasuryATA = !existingFee || existingFee.streamflowFee.gtn(0)
+            ? await checkOrCreateAtaBatch(this.connection, [STREAMFLOW_TREASURY_PUBLIC_KEY], rewardMintPk, extParams.invoker, tokenProgramPk)
+            : null;
+        const rewardPoolPda = deriveRewardPoolPDA(rewardPoolProgram.programId, pk(stakePool), rewardMintPk, nonce);
+        const instruction = await rewardPoolProgram.methods
+            .fundPool(amount)
+            .accountsPartial({
+            funder: staker,
+            rewardPool: rewardPoolPda,
+            from: getAssociatedTokenAddressSync(rewardMintPk, staker, false, tokenProgramPk),
+            tokenProgram: tokenProgramId,
+            vault: deriveRewardVaultPDA(rewardPoolProgram.programId, rewardPoolPda),
+            mint: rewardMint,
+            feeValue,
+        })
+            .instruction();
+        return { ixs: treasuryATA ? treasuryATA.concat([instruction]) : [instruction] };
+    }
+    async createRewardEntry(data, extParams) {
+        const { ixs } = await this.prepareCreateRewardEntryInstructions(data, extParams);
+        const { signature } = await this.execute(ixs, extParams);
+        return {
+            ixs,
+            txId: signature,
+        };
+    }
+    async prepareCreateRewardEntryInstructions({ stakePoolMint, stakePool, rewardPoolNonce, depositNonce }, extParams) {
+        const { stakePoolProgram, rewardPoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const instruction = await rewardPoolProgram.methods
+            .createEntry()
+            .accounts({
+            payer: staker,
+            authority: staker,
+            stakeEntry: deriveStakeEntryPDA(stakePoolProgram.programId, pk(stakePool), staker, depositNonce),
+            rewardPool: deriveRewardPoolPDA(rewardPoolProgram.programId, pk(stakePool), pk(stakePoolMint), rewardPoolNonce),
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    async execute(ixs, extParams) {
+        const { tx, hash, context } = await prepareTransaction(this.connection, ixs, extParams.invoker.publicKey);
+        try {
+            const signature = await signAndExecuteTransaction(this.connection, extParams.invoker, tx, {
+                hash,
+                context,
+                commitment: this.getCommitment(),
+            }, { sendThrottler: this.sendThrottler });
+            return { signature };
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                const parsed = translateError(err, parseIdlErrors(this.programs.stakePoolProgram.idl));
+                if (parsed) {
+                    throw new ContractError(err, parsed.name, parsed.message);
+                }
+            }
+            throw err;
+        }
+    }
+}
+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;
+    }, []);
+}