@streamflow/staking 7.5.3 → 8.0.0-alpha.p287.5172056

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

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

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

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

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

@@ -1,46 +0,0 @@
-"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/fee-amounts.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateDecimalsShift = exports.calculateFeeAmount = void 0;
-exports.calculateAmountWithTransferFees = calculateAmountWithTransferFees;
-const common_1 = require("@streamflow/common");
-const constants_js_1 = require("../constants.js");
-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;
-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, common_1.divCeilN)(numerator, denominator);
-        const fee = rawPreFeeAmount - transferAmount;
-        transferAmount = rawPreFeeAmount;
-        feeCharged = fee > transferFee.maximumFee ? transferFee.maximumFee : fee;
-    }
-    return { transferAmount, feeCharged };
-}

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

@@ -1,154 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-class RewardEntryAccumulator {
-    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_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);
-        return claimablePerEffectiveStake.mul(effectiveStakedAmount).div(constants_js_1.SCALE_PRECISION_FACTOR_BN);
-    }
-    // Calculates claimable amount from accountable amount.
-    getClaimableAmount() {
-        const claimedAmount = this.claimedAmount.mul(constants_js_1.REWARD_AMOUNT_PRECISION_FACTOR_BN);
-        const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
-        return nonClaimedAmount.div(constants_js_1.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);
-    }
-}
-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 = 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_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;
-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

@@ -1,19 +0,0 @@
-"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/cjs/solana/types.js

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

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

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

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

@@ -1,56 +0,0 @@
-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/solana/client.d.ts

@@ -1,89 +0,0 @@
-import { AccountsCoder, Idl, IdlAccounts, 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, DefaultFeeValueConfig, FeeValue, FundPoolArgs, IInteractSolanaExt, RewardEntry, RewardPool, StakeArgs, StakeEntry, StakePool, UnstakeArgs, UpdateRewardPoolArgs } 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 declare class SolanaStakingClient {
-    connection: Connection;
-    private readonly cluster;
-    private readonly commitment;
-    private readonly sendThrottler;
-    readonly programs: 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>[]>;
-    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, freezeStakeMint, unstakePeriod, 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, lastClaimPeriodOpt, 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({ stakePool, rewardPoolNonce, depositNonce, rewardMint }: CreateRewardEntryArgs, extParams: IInteractSolanaExt): Promise<{
-        ixs: TransactionInstruction[];
-    }>;
-    updateRewardPool(data: UpdateRewardPoolArgs, extParams: IInteractSolanaExt): Promise<{
-        ixs: TransactionInstruction[];
-        txId: string;
-    }>;
-    prepareUpdateRewardPoolInstructions({ rewardPool, rewardAmount, rewardPeriod, stakePool }: 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 IdlAccounts<DerivedIdl> = keyof IdlAccounts<DerivedIdl>, DecodedAccount = IdlAccounts<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 IdlAccounts<DerivedIdl> = keyof IdlAccounts<DerivedIdl>>(programKey: ProgramName, accountName: AccountName): number[];
-    private execute;
-}
-export {};