@streamflow/staking 7.5.3 → 8.0.0-alpha.p284.726ba98

package/dist/cjs/index.d.cts

@@ -0,0 +1,298 @@
+import { IdlAccounts, Address, Program, ProgramAccount, Idl, AccountsCoder } from '@coral-xyz/anchor';
+import { PublicKey, Keypair, Connection, Commitment, ConnectionConfig, TransactionInstruction } from '@solana/web3.js';
+import { ICluster, ITransactionResult } from '@streamflow/common';
+import PQueue from 'p-queue';
+import BN from 'bn.js';
+import { FeeManager } from './solana/descriptor/fee_manager.cjs';
+import { RewardPool as RewardPool$1 } from './solana/descriptor/reward_pool.cjs';
+import { StakePool as StakePool$1 } from './solana/descriptor/stake_pool.cjs';
+import { SignerWalletAdapter } from '@solana/wallet-adapter-base';
+import { ITransactionSolanaExt } from '@streamflow/common/solana';
+import { TransferFeeConfig } from '@solana/spl-token';
+
+declare const FEE_PRECISION_FACTOR = 10000;
+declare const FEE_PRECISION_FACTOR_BN: BN;
+declare const DEFAULT_FEE = 19;
+declare const DEFAULT_FEE_BN: BN;
+declare const SCALE_PRECISION_FACTOR = 1000000000;
+declare const SCALE_PRECISION_FACTOR_BN: BN;
+declare const REWARD_AMOUNT_DECIMALS = 9;
+declare const REWARD_AMOUNT_PRECISION_FACTOR = 1000000000;
+declare const REWARD_AMOUNT_PRECISION_FACTOR_BN: BN;
+declare const U64_MAX = 18446744073709551615n;
+declare const STAKE_ENTRY_DISCRIMINATOR: number[];
+declare const STAKE_ENTRY_PREFIX: Buffer;
+declare const STAKE_POOL_PREFIX: Buffer;
+declare const STAKE_MINT_PREFIX: Buffer;
+declare const STAKE_VAULT_PREFIX: Buffer;
+declare const REWARD_POOL_PREFIX: Buffer;
+declare const REWARD_VAULT_PREFIX: Buffer;
+declare const REWARD_ENTRY_PREFIX: Buffer;
+declare const CONFIG_PREFIX: Buffer;
+declare const FEE_VALUE_PREFIX: Buffer;
+declare const STREAMFLOW_TREASURY_PUBLIC_KEY: PublicKey;
+declare const ANCHOR_DISCRIMINATOR_OFFSET = 8;
+declare const STAKE_ENTRY_STAKE_POOL_OFFSET: number;
+declare const STAKE_ENTRY_PAYER_OFFSET: number;
+declare const STAKE_ENTRY_OWNER_OFFSET: number;
+declare const STAKE_ENTRY_BYTE_OFFSETS: {
+    readonly payer: number;
+    readonly authority: number;
+    readonly stakePool: number;
+};
+declare const STAKE_POOL_MINT_OFFSET: number;
+declare const STAKE_POOL_CREATOR_OFFSET: number;
+declare const STAKE_POOL_BYTE_OFFSETS: {
+    readonly mint: number;
+    readonly creator: number;
+};
+declare const REWARD_POOL_STAKE_POOL_OFFSET: number;
+declare const REWARD_POOL_MINT_OFFSET: number;
+declare const REWARD_POOL_BYTE_OFFSETS: {
+    readonly stakePool: number;
+    readonly mint: number;
+};
+declare const REWARD_ENTRY_REWARD_POOL_OFFSET = 8;
+declare const REWARD_ENTRY_STAKE_ENTRY_OFFSET: number;
+declare const REWARD_ENTRY_BYTE_OFFSETS: {
+    readonly stakeEntry: number;
+    readonly rewardPool: 8;
+};
+declare const STAKE_POOL_PROGRAM_ID: Record<ICluster, string>;
+declare const REWARD_POOL_PROGRAM_ID: Record<ICluster, string>;
+declare const FEE_PROGRAM_ID: Record<ICluster, string>;
+
+declare const constants_ANCHOR_DISCRIMINATOR_OFFSET: typeof ANCHOR_DISCRIMINATOR_OFFSET;
+declare const constants_CONFIG_PREFIX: typeof CONFIG_PREFIX;
+declare const constants_DEFAULT_FEE: typeof DEFAULT_FEE;
+declare const constants_DEFAULT_FEE_BN: typeof DEFAULT_FEE_BN;
+declare const constants_FEE_PRECISION_FACTOR: typeof FEE_PRECISION_FACTOR;
+declare const constants_FEE_PRECISION_FACTOR_BN: typeof FEE_PRECISION_FACTOR_BN;
+declare const constants_FEE_PROGRAM_ID: typeof FEE_PROGRAM_ID;
+declare const constants_FEE_VALUE_PREFIX: typeof FEE_VALUE_PREFIX;
+declare const constants_REWARD_AMOUNT_DECIMALS: typeof REWARD_AMOUNT_DECIMALS;
+declare const constants_REWARD_AMOUNT_PRECISION_FACTOR: typeof REWARD_AMOUNT_PRECISION_FACTOR;
+declare const constants_REWARD_AMOUNT_PRECISION_FACTOR_BN: typeof REWARD_AMOUNT_PRECISION_FACTOR_BN;
+declare const constants_REWARD_ENTRY_BYTE_OFFSETS: typeof REWARD_ENTRY_BYTE_OFFSETS;
+declare const constants_REWARD_ENTRY_PREFIX: typeof REWARD_ENTRY_PREFIX;
+declare const constants_REWARD_ENTRY_REWARD_POOL_OFFSET: typeof REWARD_ENTRY_REWARD_POOL_OFFSET;
+declare const constants_REWARD_ENTRY_STAKE_ENTRY_OFFSET: typeof REWARD_ENTRY_STAKE_ENTRY_OFFSET;
+declare const constants_REWARD_POOL_BYTE_OFFSETS: typeof REWARD_POOL_BYTE_OFFSETS;
+declare const constants_REWARD_POOL_MINT_OFFSET: typeof REWARD_POOL_MINT_OFFSET;
+declare const constants_REWARD_POOL_PREFIX: typeof REWARD_POOL_PREFIX;
+declare const constants_REWARD_POOL_PROGRAM_ID: typeof REWARD_POOL_PROGRAM_ID;
+declare const constants_REWARD_POOL_STAKE_POOL_OFFSET: typeof REWARD_POOL_STAKE_POOL_OFFSET;
+declare const constants_REWARD_VAULT_PREFIX: typeof REWARD_VAULT_PREFIX;
+declare const constants_SCALE_PRECISION_FACTOR: typeof SCALE_PRECISION_FACTOR;
+declare const constants_SCALE_PRECISION_FACTOR_BN: typeof SCALE_PRECISION_FACTOR_BN;
+declare const constants_STAKE_ENTRY_BYTE_OFFSETS: typeof STAKE_ENTRY_BYTE_OFFSETS;
+declare const constants_STAKE_ENTRY_DISCRIMINATOR: typeof STAKE_ENTRY_DISCRIMINATOR;
+declare const constants_STAKE_ENTRY_OWNER_OFFSET: typeof STAKE_ENTRY_OWNER_OFFSET;
+declare const constants_STAKE_ENTRY_PAYER_OFFSET: typeof STAKE_ENTRY_PAYER_OFFSET;
+declare const constants_STAKE_ENTRY_PREFIX: typeof STAKE_ENTRY_PREFIX;
+declare const constants_STAKE_ENTRY_STAKE_POOL_OFFSET: typeof STAKE_ENTRY_STAKE_POOL_OFFSET;
+declare const constants_STAKE_MINT_PREFIX: typeof STAKE_MINT_PREFIX;
+declare const constants_STAKE_POOL_BYTE_OFFSETS: typeof STAKE_POOL_BYTE_OFFSETS;
+declare const constants_STAKE_POOL_CREATOR_OFFSET: typeof STAKE_POOL_CREATOR_OFFSET;
+declare const constants_STAKE_POOL_MINT_OFFSET: typeof STAKE_POOL_MINT_OFFSET;
+declare const constants_STAKE_POOL_PREFIX: typeof STAKE_POOL_PREFIX;
+declare const constants_STAKE_POOL_PROGRAM_ID: typeof STAKE_POOL_PROGRAM_ID;
+declare const constants_STAKE_VAULT_PREFIX: typeof STAKE_VAULT_PREFIX;
+declare const constants_STREAMFLOW_TREASURY_PUBLIC_KEY: typeof STREAMFLOW_TREASURY_PUBLIC_KEY;
+declare const constants_U64_MAX: typeof U64_MAX;
+declare namespace constants {
+  export { constants_ANCHOR_DISCRIMINATOR_OFFSET as ANCHOR_DISCRIMINATOR_OFFSET, constants_CONFIG_PREFIX as CONFIG_PREFIX, constants_DEFAULT_FEE as DEFAULT_FEE, constants_DEFAULT_FEE_BN as DEFAULT_FEE_BN, constants_FEE_PRECISION_FACTOR as FEE_PRECISION_FACTOR, constants_FEE_PRECISION_FACTOR_BN as FEE_PRECISION_FACTOR_BN, constants_FEE_PROGRAM_ID as FEE_PROGRAM_ID, constants_FEE_VALUE_PREFIX as FEE_VALUE_PREFIX, constants_REWARD_AMOUNT_DECIMALS as REWARD_AMOUNT_DECIMALS, constants_REWARD_AMOUNT_PRECISION_FACTOR as REWARD_AMOUNT_PRECISION_FACTOR, constants_REWARD_AMOUNT_PRECISION_FACTOR_BN as REWARD_AMOUNT_PRECISION_FACTOR_BN, constants_REWARD_ENTRY_BYTE_OFFSETS as REWARD_ENTRY_BYTE_OFFSETS, constants_REWARD_ENTRY_PREFIX as REWARD_ENTRY_PREFIX, constants_REWARD_ENTRY_REWARD_POOL_OFFSET as REWARD_ENTRY_REWARD_POOL_OFFSET, constants_REWARD_ENTRY_STAKE_ENTRY_OFFSET as REWARD_ENTRY_STAKE_ENTRY_OFFSET, constants_REWARD_POOL_BYTE_OFFSETS as REWARD_POOL_BYTE_OFFSETS, constants_REWARD_POOL_MINT_OFFSET as REWARD_POOL_MINT_OFFSET, constants_REWARD_POOL_PREFIX as REWARD_POOL_PREFIX, constants_REWARD_POOL_PROGRAM_ID as REWARD_POOL_PROGRAM_ID, constants_REWARD_POOL_STAKE_POOL_OFFSET as REWARD_POOL_STAKE_POOL_OFFSET, constants_REWARD_VAULT_PREFIX as REWARD_VAULT_PREFIX, constants_SCALE_PRECISION_FACTOR as SCALE_PRECISION_FACTOR, constants_SCALE_PRECISION_FACTOR_BN as SCALE_PRECISION_FACTOR_BN, constants_STAKE_ENTRY_BYTE_OFFSETS as STAKE_ENTRY_BYTE_OFFSETS, constants_STAKE_ENTRY_DISCRIMINATOR as STAKE_ENTRY_DISCRIMINATOR, constants_STAKE_ENTRY_OWNER_OFFSET as STAKE_ENTRY_OWNER_OFFSET, constants_STAKE_ENTRY_PAYER_OFFSET as STAKE_ENTRY_PAYER_OFFSET, constants_STAKE_ENTRY_PREFIX as STAKE_ENTRY_PREFIX, constants_STAKE_ENTRY_STAKE_POOL_OFFSET as STAKE_ENTRY_STAKE_POOL_OFFSET, constants_STAKE_MINT_PREFIX as STAKE_MINT_PREFIX, constants_STAKE_POOL_BYTE_OFFSETS as STAKE_POOL_BYTE_OFFSETS, constants_STAKE_POOL_CREATOR_OFFSET as STAKE_POOL_CREATOR_OFFSET, constants_STAKE_POOL_MINT_OFFSET as STAKE_POOL_MINT_OFFSET, constants_STAKE_POOL_PREFIX as STAKE_POOL_PREFIX, constants_STAKE_POOL_PROGRAM_ID as STAKE_POOL_PROGRAM_ID, constants_STAKE_VAULT_PREFIX as STAKE_VAULT_PREFIX, constants_STREAMFLOW_TREASURY_PUBLIC_KEY as STREAMFLOW_TREASURY_PUBLIC_KEY, constants_U64_MAX as U64_MAX };
+}
+
+type StakePool = IdlAccounts<StakePool$1>["stakePool"];
+type StakeEntry = IdlAccounts<StakePool$1>["stakeEntry"];
+type RewardEntry = IdlAccounts<RewardPool$1>["rewardEntry"];
+type RewardPool = IdlAccounts<RewardPool$1>["rewardPool"];
+type FeeValue = IdlAccounts<FeeManager>["feeValue"];
+type DefaultFeeValueConfig = IdlAccounts<FeeManager>["config"];
+interface IInteractSolanaExt extends ITransactionSolanaExt {
+    invoker: SignerWalletAdapter | Keypair;
+}
+interface BaseStakePoolArgs {
+    stakePool: Address;
+    stakePoolMint: Address;
+}
+interface TokenProgram {
+    tokenProgramId?: Address;
+}
+interface StakeBaseArgs extends BaseStakePoolArgs, TokenProgram {
+    nonce: number;
+}
+type UnstakeArgs = StakeBaseArgs;
+interface StakeArgs extends StakeBaseArgs {
+    amount: BN;
+    duration: BN;
+    payer?: Keypair;
+    authority?: Address;
+}
+interface FundPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    amount: BN;
+    nonce: number;
+    rewardMint: Address;
+    feeValue: Address | null;
+}
+interface CreateRewardEntryArgs extends BaseStakePoolArgs, TokenProgram {
+    depositNonce: number;
+    rewardPoolNonce: number;
+    rewardMint: Address;
+}
+interface CreateRewardPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    stakePoolNonce: number;
+    rewardMint: Address;
+    nonce: number;
+    rewardAmount: BN;
+    rewardPeriod: BN;
+    permissionless: boolean;
+    lastClaimPeriodOpt: BN | null;
+}
+interface UpdateRewardPoolArgs {
+    stakePool: Address;
+    rewardAmount: BN | null;
+    rewardPeriod: BN | null;
+    rewardPool: Address;
+}
+interface ClaimRewardPoolArgs extends BaseStakePoolArgs, TokenProgram {
+    depositNonce: number;
+    rewardMint: Address;
+    rewardPoolNonce: number;
+}
+interface CreateStakePoolArgs extends TokenProgram {
+    mint: Address;
+    nonce: number;
+    maxWeight: BN;
+    minDuration: BN;
+    maxDuration: BN;
+    permissionless?: boolean;
+    freezeStakeMint?: boolean | null;
+    unstakePeriod?: BN | null;
+    authority?: Keypair;
+}
+
+interface Programs {
+    stakePoolProgram: Program<StakePool$1>;
+    rewardPoolProgram: Program<RewardPool$1>;
+    feeManagerProgram: Program<FeeManager>;
+}
+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;
+}
+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;
+}
+
+declare const deriveStakePoolPDA: (programId: PublicKey, mint: PublicKey, authority: PublicKey, nonce: number) => PublicKey;
+declare const deriveStakeVaultPDA: (programId: PublicKey, stakePool: PublicKey) => PublicKey;
+declare const deriveStakeMintPDA: (programId: PublicKey, stakePool: PublicKey) => PublicKey;
+declare const deriveStakeEntryPDA: (programId: PublicKey, stakePool: PublicKey, authority: PublicKey, nonce: number) => PublicKey;
+declare const deriveRewardPoolPDA: (programId: PublicKey, stakePool: PublicKey, mint: PublicKey, nonce: number) => PublicKey;
+declare const deriveRewardVaultPDA: (programId: PublicKey, rewardPool: PublicKey) => PublicKey;
+declare const deriveRewardEntryPDA: (programId: PublicKey, rewardPool: PublicKey, stakeEntry: PublicKey) => PublicKey;
+declare const deriveConfigPDA: (programId: PublicKey) => PublicKey;
+declare const deriveFeeValuePDA: (programId: PublicKey, target: PublicKey) => PublicKey;
+
+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;
+}
+declare const calcRewards: (rewardEntryAccount: ProgramAccount<RewardEntry> | undefined, stakeEntryAccount: ProgramAccount<StakeEntry>, rewardPoolAccount: ProgramAccount<RewardPool>) => BN;
+declare const calculateRewardRateFromAmount: (rewardAmount: BN, stakeTokenDecimals: number, rewardTokenDecimals: number) => number;
+declare const calculateRewardAmountFromValue: (rewardTokenValue: BN, stakeTokenDecimals: number) => BN;
+declare const calculateRewardAmountFromRate: (rewardRate: number, stakeTokenDecimals: number, rewardTokenDecimals: number) => BN;
+
+declare const calculateFeeAmount: (amount: BN, fee?: BN) => BN;
+declare const calculateDecimalsShift: (maxWeight: bigint, maxShift?: number) => number;
+declare function calculateAmountWithTransferFees(connection: Connection, transferFeeConfig: TransferFeeConfig, transferAmount: bigint): Promise<{
+    transferAmount: bigint;
+    feeCharged: bigint;
+}>;
+
+declare const calculateStakeWeight: (minDuration: BN, maxDuration: BN, maxWeight: BN, duration: BN) => BN;
+
+export { type BaseStakePoolArgs, type ClaimRewardPoolArgs, type CreateRewardEntryArgs, type CreateRewardPoolArgs, type CreateStakePoolArgs, type DefaultFeeValueConfig, type FeeValue, type FundPoolArgs, type IInteractSolanaExt, type RewardEntry, RewardEntryAccumulator, type RewardPool, SolanaStakingClient, type StakeArgs, type StakeEntry, type StakePool, type UnstakeArgs, type UpdateRewardPoolArgs, calcRewards, calculateAmountWithTransferFees, calculateDecimalsShift, calculateFeeAmount, calculateRewardAmountFromRate, calculateRewardAmountFromValue, calculateRewardRateFromAmount, calculateStakeWeight, constants, deriveConfigPDA, deriveFeeValuePDA, deriveRewardEntryPDA, deriveRewardPoolPDA, deriveRewardVaultPDA, deriveStakeEntryPDA, deriveStakeMintPDA, deriveStakePoolPDA, deriveStakeVaultPDA };

package/dist/cjs/solana/descriptor/fee_manager.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=fee_manager.cjs.map
+//# sourceMappingURL=fee_manager.cjs.map

package/dist/cjs/solana/descriptor/fee_manager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"fee_manager.cjs"}

package/dist/cjs/solana/descriptor/fee_manager.d.cts

@@ -0,0 +1,292 @@
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/fee_manager.json`.
+ */
+type FeeManager = {
+    address: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V";
+    metadata: {
+        name: "feeManager";
+        version: "1.0.0";
+        spec: "0.1.0";
+        description: "Stores Fees and other admin configuration for the Staking protocol";
+    };
+    instructions: [
+        {
+            name: "changeAuthority";
+            discriminator: [50, 106, 66, 104, 99, 118, 145, 88];
+            accounts: [
+                {
+                    name: "config";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "authority";
+                    docs: ["authority"];
+                    signer: true;
+                },
+                {
+                    name: "newAuthority";
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "initialize";
+            discriminator: [175, 175, 109, 31, 13, 152, 155, 237];
+            accounts: [
+                {
+                    name: "config";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "authority";
+                    docs: ["authority"];
+                    writable: true;
+                    signer: true;
+                    address: "ACYtYsL4KYtJzD53wqyifqad2D8224kamcngYPgSy3t";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "removeFee";
+            discriminator: [190, 227, 105, 10, 30, 161, 81, 212];
+            accounts: [
+                {
+                    name: "feeValue";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [102, 101, 101, 45, 118, 97, 108, 117, 101];
+                            },
+                            {
+                                kind: "account";
+                                path: "target";
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "config";
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "authority";
+                    docs: ["authority"];
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "target";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "updateConfig";
+            discriminator: [29, 158, 252, 191, 10, 83, 219, 99];
+            accounts: [
+                {
+                    name: "config";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "authority";
+                    docs: ["authority"];
+                    signer: true;
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [
+                {
+                    name: "streamflowFee";
+                    type: {
+                        option: "u64";
+                    };
+                }
+            ];
+        },
+        {
+            name: "writeFee";
+            discriminator: [80, 12, 148, 143, 16, 120, 24, 48];
+            accounts: [
+                {
+                    name: "feeValue";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [102, 101, 101, 45, 118, 97, 108, 117, 101];
+                            },
+                            {
+                                kind: "account";
+                                path: "target";
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "config";
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "authority";
+                    docs: ["authority"];
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "target";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [
+                {
+                    name: "streamflowFee";
+                    type: "u64";
+                }
+            ];
+        }
+    ];
+    accounts: [
+        {
+            name: "config";
+            discriminator: [155, 12, 170, 224, 30, 250, 204, 130];
+        },
+        {
+            name: "feeValue";
+            discriminator: [10, 188, 89, 64, 4, 183, 231, 0];
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            name: "unauthorized";
+            msg: "Account is not authorized to execute this instruction";
+        },
+        {
+            code: 6001;
+            name: "invalidFee";
+            msg: "Provided fee is not valid";
+        }
+    ];
+    types: [
+        {
+            name: "config";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "authority";
+                        docs: ["Fee Manager authority"];
+                        type: "pubkey";
+                    },
+                    {
+                        name: "streamflowFee";
+                        docs: ["Default fee"];
+                        type: "u64";
+                    },
+                    {
+                        name: "buffer1";
+                        docs: ["Buffer for additional fields"];
+                        type: {
+                            array: ["u8", 64];
+                        };
+                    },
+                    {
+                        name: "buffer2";
+                        docs: ["Buffer for additional fields"];
+                        type: {
+                            array: ["u8", 64];
+                        };
+                    },
+                    {
+                        name: "buffer3";
+                        docs: ["Buffer for additional fields"];
+                        type: {
+                            array: ["u8", 64];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "feeValue";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "streamflowFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "buffer";
+                        docs: ["Buffer for additional fields"];
+                        type: {
+                            array: ["u8", 64];
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+};
+
+export type { FeeManager };

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

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=reward_pool.cjs.map
+//# sourceMappingURL=reward_pool.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"reward_pool.cjs"}