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

package/dist/esm/solana/client.js

@@ -1,334 +0,0 @@
-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, invariant } from "@streamflow/common";
-import { buildSendThrottler, checkOrCreateAtaBatch, getFilters, pk, prepareBaseInstructions, 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 { deriveConfigPDA, deriveFeeValuePDA, deriveRewardPoolPDA, deriveRewardVaultPDA, deriveStakeEntryPDA, deriveStakeMintPDA, deriveStakePoolPDA, } from "./lib/derive-accounts.js";
-export class SolanaStakingClient {
-    connection;
-    cluster;
-    commitment;
-    sendThrottler;
-    programs;
-    constructor({ clusterUrl, cluster = ICluster.Mainnet, commitment = "confirmed", programIds, sendRate = 1, sendThrottler, }) {
-        this.cluster = cluster;
-        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));
-    }
-    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));
-        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, freezeStakeMint = null, unstakePeriod = null, 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, freezeStakeMint, unstakePeriod)
-            .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, true, pk(tokenProgramId));
-        const poolMintAccountKey = getAssociatedTokenAddressSync(pk(stakePoolMint), staker, true, 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, true, pk(tokenProgramId));
-        const stakeMintAccountKey = getAssociatedTokenAddressSync(stakeMintKey, staker, true, 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, lastClaimPeriodOpt, 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, lastClaimPeriodOpt)
-            .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, true, 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, true, 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({ stakePool, rewardPoolNonce, depositNonce, rewardMint }, 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(rewardMint), rewardPoolNonce),
-        })
-            .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, stakePool }, extParams) {
-        const { rewardPoolProgram } = this.programs;
-        const invoker = extParams.invoker.publicKey;
-        invariant(invoker, "Undefined invoker publicKey");
-        const instruction = await rewardPoolProgram.methods
-            .updatePool(rewardAmount, rewardPeriod)
-            .accountsPartial({
-            stakePool,
-            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, prepareBaseInstructions(this.connection, extParams).concat(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;
-        }
-    }
-}

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

@@ -1,54 +0,0 @@
-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 = 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;
-export declare const STAKE_POOL_PREFIX: Buffer;
-export declare const STAKE_MINT_PREFIX: Buffer;
-export declare const STAKE_VAULT_PREFIX: Buffer;
-export declare const REWARD_POOL_PREFIX: Buffer;
-export declare const REWARD_VAULT_PREFIX: Buffer;
-export declare const REWARD_ENTRY_PREFIX: Buffer;
-export declare const CONFIG_PREFIX: Buffer;
-export declare const FEE_VALUE_PREFIX: Buffer;
-export declare const STREAMFLOW_TREASURY_PUBLIC_KEY: PublicKey;
-export declare const ANCHOR_DISCRIMINATOR_OFFSET = 8;
-export declare const STAKE_ENTRY_STAKE_POOL_OFFSET: number;
-export declare const STAKE_ENTRY_PAYER_OFFSET: number;
-export declare const STAKE_ENTRY_OWNER_OFFSET: number;
-export declare const STAKE_ENTRY_BYTE_OFFSETS: {
-    readonly payer: number;
-    readonly authority: number;
-    readonly stakePool: number;
-};
-export declare const STAKE_POOL_MINT_OFFSET: number;
-export declare const STAKE_POOL_CREATOR_OFFSET: number;
-export declare const STAKE_POOL_BYTE_OFFSETS: {
-    readonly mint: number;
-    readonly creator: number;
-};
-export declare const REWARD_POOL_STAKE_POOL_OFFSET: number;
-export declare const REWARD_POOL_MINT_OFFSET: number;
-export declare const REWARD_POOL_BYTE_OFFSETS: {
-    readonly stakePool: number;
-    readonly mint: number;
-};
-export declare const REWARD_ENTRY_REWARD_POOL_OFFSET = 8;
-export declare const REWARD_ENTRY_STAKE_ENTRY_OFFSET: number;
-export declare const REWARD_ENTRY_BYTE_OFFSETS: {
-    readonly stakeEntry: number;
-    readonly rewardPool: 8;
-};
-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,69 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { ICluster } from "@streamflow/common";
-import { PublicKey } from "@solana/web3.js";
-export const FEE_PRECISION_FACTOR = 10_000;
-export const FEE_PRECISION_FACTOR_BN = new BN(FEE_PRECISION_FACTOR);
-export const DEFAULT_FEE = 19;
-export const DEFAULT_FEE_BN = new BN(DEFAULT_FEE);
-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");
-export const STAKE_POOL_PREFIX = Buffer.from("stake-pool", "utf-8");
-export const STAKE_MINT_PREFIX = Buffer.from("stake-mint", "utf-8");
-export const STAKE_VAULT_PREFIX = Buffer.from("stake-vault", "utf-8");
-export const REWARD_POOL_PREFIX = Buffer.from("reward-pool", "utf-8");
-export const REWARD_VAULT_PREFIX = Buffer.from("reward-vault", "utf-8");
-export const REWARD_ENTRY_PREFIX = Buffer.from("reward-entry", "utf-8");
-export const CONFIG_PREFIX = Buffer.from("config", "utf-8");
-export const FEE_VALUE_PREFIX = Buffer.from("fee-value", "utf-8");
-export const STREAMFLOW_TREASURY_PUBLIC_KEY = new PublicKey("5SEpbdjFK5FxwTvfsGMXVQTD2v4M2c5tyRTxhdsPkgDw");
-export const ANCHOR_DISCRIMINATOR_OFFSET = 8;
-export const STAKE_ENTRY_STAKE_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 4;
-export const STAKE_ENTRY_PAYER_OFFSET = STAKE_ENTRY_STAKE_POOL_OFFSET + 32;
-export const STAKE_ENTRY_OWNER_OFFSET = STAKE_ENTRY_PAYER_OFFSET + 32;
-export const STAKE_ENTRY_BYTE_OFFSETS = {
-    payer: STAKE_ENTRY_PAYER_OFFSET,
-    authority: STAKE_ENTRY_OWNER_OFFSET,
-    stakePool: STAKE_ENTRY_STAKE_POOL_OFFSET,
-};
-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,
-    creator: STAKE_POOL_CREATOR_OFFSET,
-};
-export const REWARD_POOL_STAKE_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 2;
-export const REWARD_POOL_MINT_OFFSET = REWARD_POOL_STAKE_POOL_OFFSET + 32;
-export const REWARD_POOL_BYTE_OFFSETS = {
-    stakePool: REWARD_POOL_STAKE_POOL_OFFSET,
-    mint: REWARD_POOL_MINT_OFFSET,
-};
-export const REWARD_ENTRY_REWARD_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET;
-export const REWARD_ENTRY_STAKE_ENTRY_OFFSET = REWARD_ENTRY_REWARD_POOL_OFFSET + 32;
-export const REWARD_ENTRY_BYTE_OFFSETS = {
-    stakeEntry: REWARD_ENTRY_STAKE_ENTRY_OFFSET,
-    rewardPool: REWARD_ENTRY_REWARD_POOL_OFFSET,
-};
-export const STAKE_POOL_PROGRAM_ID = {
-    [ICluster.Mainnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
-    [ICluster.Devnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
-    [ICluster.Testnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
-    [ICluster.Local]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
-};
-export const REWARD_POOL_PROGRAM_ID = {
-    [ICluster.Mainnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
-    [ICluster.Devnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
-    [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/lib/derive-accounts.d.ts

@@ -1,10 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-export declare const deriveStakePoolPDA: (programId: PublicKey, mint: PublicKey, authority: PublicKey, nonce: number) => PublicKey;
-export declare const deriveStakeVaultPDA: (programId: PublicKey, stakePool: PublicKey) => PublicKey;
-export declare const deriveStakeMintPDA: (programId: PublicKey, stakePool: PublicKey) => PublicKey;
-export declare const deriveStakeEntryPDA: (programId: PublicKey, stakePool: PublicKey, authority: PublicKey, nonce: number) => PublicKey;
-export declare const deriveRewardPoolPDA: (programId: PublicKey, stakePool: PublicKey, mint: PublicKey, nonce: number) => PublicKey;
-export declare const deriveRewardVaultPDA: (programId: PublicKey, rewardPool: PublicKey) => PublicKey;
-export declare const deriveRewardEntryPDA: (programId: PublicKey, rewardPool: PublicKey, stakeEntry: PublicKey) => PublicKey;
-export declare const deriveConfigPDA: (programId: PublicKey) => PublicKey;
-export declare const deriveFeeValuePDA: (programId: PublicKey, target: PublicKey) => PublicKey;

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

@@ -1,31 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-// eslint-disable-next-line no-restricted-imports
-import BN from "bn.js";
-import { STAKE_POOL_PREFIX, STAKE_VAULT_PREFIX, STAKE_MINT_PREFIX, STAKE_ENTRY_PREFIX, REWARD_POOL_PREFIX, REWARD_VAULT_PREFIX, REWARD_ENTRY_PREFIX, CONFIG_PREFIX, FEE_VALUE_PREFIX, } from "../constants.js";
-export const deriveStakePoolPDA = (programId, mint, authority, nonce) => {
-    return PublicKey.findProgramAddressSync([STAKE_POOL_PREFIX, mint.toBuffer(), authority.toBuffer(), new BN(nonce).toArrayLike(Buffer, "le", 1)], programId)[0];
-};
-export const deriveStakeVaultPDA = (programId, stakePool) => {
-    return PublicKey.findProgramAddressSync([STAKE_VAULT_PREFIX, stakePool.toBuffer()], programId)[0];
-};
-export const deriveStakeMintPDA = (programId, stakePool) => {
-    return PublicKey.findProgramAddressSync([STAKE_MINT_PREFIX, stakePool.toBuffer()], programId)[0];
-};
-export const deriveStakeEntryPDA = (programId, stakePool, authority, nonce) => {
-    return PublicKey.findProgramAddressSync([STAKE_ENTRY_PREFIX, stakePool.toBuffer(), authority.toBuffer(), new BN(nonce).toArrayLike(Buffer, "le", 4)], programId)[0];
-};
-export const deriveRewardPoolPDA = (programId, stakePool, mint, nonce) => {
-    return PublicKey.findProgramAddressSync([REWARD_POOL_PREFIX, stakePool.toBuffer(), mint.toBuffer(), new BN(nonce).toArrayLike(Buffer, "le", 1)], programId)[0];
-};
-export const deriveRewardVaultPDA = (programId, rewardPool) => {
-    return PublicKey.findProgramAddressSync([REWARD_VAULT_PREFIX, rewardPool.toBuffer()], programId)[0];
-};
-export const deriveRewardEntryPDA = (programId, rewardPool, stakeEntry) => {
-    return PublicKey.findProgramAddressSync([REWARD_ENTRY_PREFIX, rewardPool.toBuffer(), stakeEntry.toBuffer()], programId)[0];
-};
-export const deriveConfigPDA = (programId) => {
-    return PublicKey.findProgramAddressSync([CONFIG_PREFIX], programId)[0];
-};
-export const deriveFeeValuePDA = (programId, target) => {
-    return PublicKey.findProgramAddressSync([FEE_VALUE_PREFIX, target.toBuffer()], programId)[0];
-};

package/dist/esm/solana/lib/fee-amounts.d.ts

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

package/dist/esm/solana/lib/fee-amounts.js

@@ -1,38 +0,0 @@
-import { divCeilN } from "@streamflow/common";
-import { DEFAULT_FEE_BN, FEE_PRECISION_FACTOR_BN, SCALE_PRECISION_FACTOR, U64_MAX } from "../constants.js";
-export const calculateFeeAmount = (amount, fee = DEFAULT_FEE_BN) => {
-    if (fee.eq(FEE_PRECISION_FACTOR_BN)) {
-        return amount;
-    }
-    return amount.mul(fee).div(FEE_PRECISION_FACTOR_BN);
-};
-export const calculateDecimalsShift = (maxWeight, maxShift = 999) => {
-    if (maxShift == 0) {
-        return 0;
-    }
-    let decimalsShift = 0;
-    while ((maxWeight * U64_MAX) / BigInt(SCALE_PRECISION_FACTOR) / BigInt(10 ** decimalsShift) > U64_MAX) {
-        decimalsShift += 1;
-        if (decimalsShift == maxShift) {
-            return maxShift;
-        }
-    }
-    return decimalsShift;
-};
-export async function calculateAmountWithTransferFees(connection, transferFeeConfig, transferAmount) {
-    const epoch = await connection.getEpochInfo();
-    const transferFee = epoch.epoch >= transferFeeConfig.newerTransferFee.epoch
-        ? transferFeeConfig.newerTransferFee
-        : transferFeeConfig.olderTransferFee;
-    const transferFeeBasisPoints = BigInt(transferFee.transferFeeBasisPoints);
-    let feeCharged = BigInt(0);
-    if (transferFeeBasisPoints !== BigInt(0)) {
-        const numerator = transferAmount * 10000n;
-        const denominator = 10000n - transferFeeBasisPoints;
-        const rawPreFeeAmount = divCeilN(numerator, denominator);
-        const fee = rawPreFeeAmount - transferAmount;
-        transferAmount = rawPreFeeAmount;
-        feeCharged = fee > transferFee.maximumFee ? transferFee.maximumFee : fee;
-    }
-    return { transferAmount, feeCharged };
-}

package/dist/esm/solana/lib/rewards.d.ts

@@ -1,26 +0,0 @@
-import { ProgramAccount } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-import BN from "bn.js";
-import { RewardEntry, RewardPool, StakeEntry } from "../types.js";
-export declare class RewardEntryAccumulator implements RewardEntry {
-    lastAccountedTs: BN;
-    claimedAmount: BN;
-    accountedAmount: BN;
-    rewardPool: PublicKey;
-    stakeEntry: PublicKey;
-    createdTs: BN;
-    lastRewardAmount: BN;
-    lastRewardPeriod: BN;
-    buffer: number[];
-    constructor(lastAccountedTs: BN, claimedAmount: BN, accountedAmount: BN, rewardPool: PublicKey, stakeEntry: PublicKey, createdTs: BN, lastRewardAmount: BN, lastRewardPeriod: BN, buffer: number[]);
-    static fromEntry(entry: RewardEntry): RewardEntryAccumulator;
-    getAccountableAmount(stakedTs: BN, accountableTs: BN, effectiveStakedAmount: BN, rewardAmount: BN, rewardPeriod: BN): BN;
-    getClaimableAmount(): BN;
-    getLastAccountedTs(stakedTs: BN, claimableTs: BN, rewardPeriod: BN): BN;
-    addAccountedAmount(accountedAmount: BN): void;
-    addClaimedAmount(claimedAmount: BN): void;
-}
-export declare const calcRewards: (rewardEntryAccount: ProgramAccount<RewardEntry> | undefined, stakeEntryAccount: ProgramAccount<StakeEntry>, rewardPoolAccount: ProgramAccount<RewardPool>) => BN;
-export declare const calculateRewardRateFromAmount: (rewardAmount: BN, stakeTokenDecimals: number, rewardTokenDecimals: number) => number;
-export declare const calculateRewardAmountFromValue: (rewardTokenValue: BN, stakeTokenDecimals: number) => BN;
-export declare const calculateRewardAmountFromRate: (rewardRate: number, stakeTokenDecimals: number, rewardTokenDecimals: number) => BN;