@streamflow/staking 7.0.0-alpha.6

package/README.md

@@ -0,0 +1,216 @@
+# Streamflow Staking
+
+## JS SDK to interact with Streamflow Staking.
+
+This package allows you to 
+- `create staking pools and rewards pools`;
+- `claim rewards`; 
+- `stake`; 
+- `unstake`; 
+- `fund rewards pools`;
+
+with the Streamflow Staking protocol.
+
+This protocol is the complex of several programs which ensures flexibility and accountability for stakers and respective incentives for them.
+
+aforementioned programs are: 
+- Stake Pools Program
+- Reward Pools Program
+- Fee Management Program (for streamflow usage, non-required and ommited from further docs)
+
+
+## API Reference
+API Documentation available here: [docs site →](https://streamflow-finance.github.io/js-sdk/)
+
+The Stake Pool Program entities:
+1. Stake Pool
+2. Stake Entry (PDA which stores info about current stakes, durations and rewards structure)
+
+The Reward Pool Program entities:
+1. Reward Pool (must has a back-reference to a stake pool)
+2. Reward Entry (PDA stores claims information and time-bound params)
+
+1 Stake Pool can have N Reward Pools. 
+
+> [!NOTE]
+> There is a limitation of 255 Reward Pools per a single token mint for a stake pool.
+
+
+## Installation
+
+Install the sdk with npm
+
+```npm
+  npm install @streamflow/staking
+```
+```yarn
+  yarn install @streamflow/staking
+```
+```pnpm
+  pnpm add @streamflow/staking
+```
+
+## Usage/Examples
+
+#### Create a client
+```typescript
+const client = new SolanaStakingClient({
+  clusterUrl: "https://api.mainnet-beta.solana.com",
+  cluster: ICluster.Mainnet
+});
+```
+
+> [!WARNING]
+> All operations expect ATAs to be created at the moment of execution and don't add these instructions.
+> - Stake - staker's ATAs for stake mint and stake mint (see deriveStakeMintPDA fn) 
+> - Withdraw/Unstake - staker's ATAs for stake mint and stake mint (see deriveStakeMintPDA fn) 
+> - Claim rewards - staker's ATAs for reward mint
+> - Fund Reward Pool - signer creates Streamflow Treasury's ATA for holding fee if defined
+
+#### Read operations
+```typescript
+
+await client.searchStakePools({ mint, creator }) // returns results of lookup, `mint` and `creator` both optional. Omit the argument to get all pools
+
+await client.searchStakeEntries({ payer, stakePool }) // returns all stake entries. Omit the argument to get all.
+
+await client.searchRewardPools({ stakePool, mint })
+
+await client.searchRewardEntries({ stakeEntry, rewardPool })
+
+```
+
+#### Create a staking pool
+
+```typescript
+const client = new SolanaStakingClient({
+  clusterUrl: "https://api.mainnet-beta.solana.com",
+  cluster: ICluster.Mainnet
+});
+/*
+  Rewards Multiplier powered by 10^9.  
+  Example: if multiplier is 2_000_000_000 than stakes for maxDuration will have 2x more rewards than stakes for minDuration
+*/
+const multiplier = new BN(1_000_000_000);
+/*
+  30 days - Unix time in seconds
+*/
+const maxDuration = new BN(2592000);
+/*
+ 1 day - Unix time in seconds
+*/
+const maxDuration = new BN(86400);
+/*
+ Limits signers that can create/assign reward pools to this stake pool. True - anyone can
+*/
+const permissionless = false;
+/*
+  [0;256) derive stake pool PDA account address. 
+  If stake pool with the same mint already exists, it is required to pick a vacant nonce 
+*/
+const nonce = 0;
+
+const { metadataId: stakePoolPda } = await client.createStakePool({
+    maxWeight: multiplier,
+    maxDuration,
+    minDuration,
+    mint: MINT_ADDRESS,
+    permissionless,
+    nonce: 
+})
+
+```
+
+#### Create a rewardPool pool
+```typescript
+/*
+  [0;256) derive reward pool PDA account address.  
+  If reward pool with the same mint already exists, it is required to pick a vacant nonce 
+*/
+const nonce = 0;
+/*
+ Amount of rewarding tokens stakers get in return for staking exactly 1 token to the staking pool
+*/
+const rewardAmount = new BN(100);
+/*
+ 1 day - Unix time in seconds. Period for rewarding stakers. Period starts counting from the moment of staking
+*/
+const rewardPeriod = new BN(86400);
+const rewardMint = REWARD_MINT_ADDRESS; // rewarding token
+/*
+ Whether to allow anyone to fund this reward pool. If true anyone can fund, otherwise only the creator can
+*/
+const permissionless = true;
+
+client.createRewardPool({
+      nonce,
+      rewardAmount,
+      rewardPeriod,
+      rewardMint,
+      permissionless = false,
+      stakePool: stakePoolPda,
+      stakePoolMint: MINT_ADDRESS,
+    })
+```
+
+
+#### Deposit/Stake to a stake pool
+```typescript
+/*
+  [0;256) derive stake entry PDA account address.  
+  If stake entry with the same nonce already exists, it is required to pick a vacant one
+*/
+const nonce = 0; 
+const amount = new BN(1000); // tokens to stake
+const duration = new BN(86400 * 2) // 2 days, must be in the range of stakePool's min and max durations
+await client.stake({ nonce, amount, duration, stakePool, stakePoolMint });
+```
+
+#### Unstake/Withdraw to a stake pool
+```typescript
+/*
+  Usually to achieve this the app already loaded available stakeEntries.   
+  Stake Entry holds used `nonce`, so `nonce` below could be taken from the stake entry
+*/
+
+/*
+  [0;256) derived stake entry PDA account address.  
+  If stake entry with the same nonce already exists, it is required to pick a vacant one
+ */ 
+const nonce = 0; // 
+await client.unstake({ stakePool, stakePoolMint, nonce });
+```
+
+#### Claim a reward
+Since each stake entry can produce multiple rewards (single claim per each reward pool linked to the staking pool) this operation 
+can be triggered for every reward pool separately.
+
+```typescript
+await client.claimRewards({
+  rewardPoolNonce,
+  depositNonce,
+  stakePool,
+  rewardMint,
+});
+```
+
+> [!Note]
+> All operations have accompanying APIs for manual transaction building. Consult with API docs to find respective calls.  
+> For instance, prepareClaimRewardsInstructions.  
+> These APIs allow to aggregate multiple operations in a single transaction according to the app needs.  
+
+## Appendix
+
+Streamflow Staking protocol program IDs
+
+| Solana  |                                              |
+| ------- | -------------------------------------------- |
+| Staking Pools Mainnet   | STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH  |
+| Reward Pools Mainnet   | RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj  |
+| ----   | ---  |
+| Staking Pools Devnet   | STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH  |
+| Reward Pools Devnet   | RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj  |
+
+### IDLs
+For further details you can consult with IDLs of protocols available at:
+`@streamflow/staking/dist/esm/solana/descriptor`

package/dist/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = exports.SolanaStakingClient = void 0;
+var client_js_1 = require("./solana/client.js");
+Object.defineProperty(exports, "SolanaStakingClient", { enumerable: true, get: function () { return __importDefault(client_js_1).default; } });
+__exportStar(require("./solana/utils.js"), exports);
+__exportStar(require("./solana/types.js"), exports);
+__exportStar(require("./solana/lib/derive-accounts.js"), exports);
+__exportStar(require("./solana/lib/rewards.js"), exports);
+exports.constants = __importStar(require("./solana/constants.js"));

package/dist/cjs/solana/client.js

@@ -0,0 +1,315 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("@streamflow/common");
+const solana_1 = require("@streamflow/common/solana");
+const constants_js_1 = require("./constants.js");
+const fee_manager_json_1 = __importDefault(require("./descriptor/idl/fee_manager.json"));
+const reward_pool_json_1 = __importDefault(require("./descriptor/idl/reward_pool.json"));
+const stake_pool_json_1 = __importDefault(require("./descriptor/idl/stake_pool.json"));
+const derive_accounts_js_1 = require("./lib/derive-accounts.js");
+class SolanaStakingClient {
+    constructor({ clusterUrl, cluster = common_1.ICluster.Mainnet, commitment = "confirmed", programIds, sendRate = 1, sendThrottler, }) {
+        this.commitment = commitment;
+        this.connection = new web3_js_1.Connection(clusterUrl, this.commitment);
+        this.sendThrottler = sendThrottler ?? (0, solana_1.buildSendThrottler)(sendRate);
+        const stakePoolIdl = {
+            ...stake_pool_json_1.default,
+            address: programIds?.stakePool ?? constants_js_1.STAKE_POOL_PROGRAM_ID[cluster] ?? stake_pool_json_1.default.address,
+        };
+        const rewardPoolIdl = {
+            ...reward_pool_json_1.default,
+            address: programIds?.rewardPool ?? constants_js_1.REWARD_POOL_PROGRAM_ID[cluster] ?? reward_pool_json_1.default.address,
+        };
+        const feeManagerIdl = {
+            ...fee_manager_json_1.default,
+            address: programIds?.feeManager ?? fee_manager_json_1.default.address,
+        };
+        this.programs = {
+            stakePoolProgram: new anchor_1.Program(stakePoolIdl, {
+                connection: this.connection,
+            }),
+            rewardPoolProgram: new anchor_1.Program(rewardPoolIdl, {
+                connection: this.connection,
+            }),
+            feeManagerProgram: new anchor_1.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, constants_js_1.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, constants_js_1.STAKE_ENTRY_BYTE_OFFSETS));
+    }
+    async searchRewardPools(criteria = {}) {
+        const { rewardPoolProgram } = this.programs;
+        return rewardPoolProgram.account.rewardPool.all(getFilters(criteria, constants_js_1.REWARD_POOL_BYTE_OFFSETS));
+    }
+    async searchRewardEntries(criteria) {
+        const { rewardPoolProgram } = this.programs;
+        return rewardPoolProgram.account.rewardEntry.all(getFilters(criteria, constants_js_1.REWARD_ENTRY_BYTE_OFFSETS));
+    }
+    getFeeValueIfExists(target) {
+        const { feeManagerProgram } = this.programs;
+        const feeValueKey = (0, derive_accounts_js_1.deriveFeeValuePDA)(feeManagerProgram.programId, new web3_js_1.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 = spl_token_1.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 = (0, derive_accounts_js_1.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 = spl_token_1.TOKEN_PROGRAM_ID }, extParams) {
+        const { stakePoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const mint = (0, derive_accounts_js_1.deriveStakeMintPDA)(stakePoolProgram.programId, pk(stakePool));
+        const stakeMintAccountKey = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, staker, false, pk(tokenProgramId));
+        const poolMintAccountKey = (0, spl_token_1.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 = spl_token_1.TOKEN_PROGRAM_ID }, extParams) {
+        const { stakePoolProgram } = this.programs;
+        const staker = extParams.invoker.publicKey;
+        invariant(staker, "Undefined invoker publicKey");
+        const stakeMintKey = (0, derive_accounts_js_1.deriveStakeMintPDA)(stakePoolProgram.programId, pk(stakePool));
+        const stakeEntryKey = (0, derive_accounts_js_1.deriveStakeEntryPDA)(stakePoolProgram.programId, pk(stakePool), staker, nonce);
+        const poolMintAccountKey = (0, spl_token_1.getAssociatedTokenAddressSync)(pk(stakePoolMint), staker, false, pk(tokenProgramId));
+        const stakeMintAccountKey = (0, spl_token_1.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 = spl_token_1.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 = (0, derive_accounts_js_1.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 = spl_token_1.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: (0, derive_accounts_js_1.deriveStakeEntryPDA)(stakePoolProgram.programId, pk(stakePool), staker, depositNonce),
+            rewardPool: (0, derive_accounts_js_1.deriveRewardPoolPDA)(rewardPoolProgram.programId, pk(stakePool), pk(rewardMint), rewardPoolNonce),
+            claimant: staker,
+            tokenProgram: tokenProgramId,
+            to: (0, spl_token_1.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 = spl_token_1.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 (0, solana_1.checkOrCreateAtaBatch)(this.connection, [constants_js_1.STREAMFLOW_TREASURY_PUBLIC_KEY], rewardMintPk, extParams.invoker, tokenProgramPk)
+            : null;
+        const rewardPoolPda = (0, derive_accounts_js_1.deriveRewardPoolPDA)(rewardPoolProgram.programId, pk(stakePool), rewardMintPk, nonce);
+        const instruction = await rewardPoolProgram.methods
+            .fundPool(amount)
+            .accountsPartial({
+            funder: staker,
+            rewardPool: rewardPoolPda,
+            from: (0, spl_token_1.getAssociatedTokenAddressSync)(rewardMintPk, staker, false, tokenProgramPk),
+            tokenProgram: tokenProgramId,
+            vault: (0, derive_accounts_js_1.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: (0, derive_accounts_js_1.deriveStakeEntryPDA)(stakePoolProgram.programId, pk(stakePool), staker, depositNonce),
+            rewardPool: (0, derive_accounts_js_1.deriveRewardPoolPDA)(rewardPoolProgram.programId, pk(stakePool), pk(stakePoolMint), rewardPoolNonce),
+        })
+            .instruction();
+        return { ixs: [instruction] };
+    }
+    async execute(ixs, extParams) {
+        const { tx, hash, context } = await (0, solana_1.prepareTransaction)(this.connection, ixs, extParams.invoker.publicKey);
+        try {
+            const signature = await (0, solana_1.signAndExecuteTransaction)(this.connection, extParams.invoker, tx, {
+                hash,
+                context,
+                commitment: this.getCommitment(),
+            }, { sendThrottler: this.sendThrottler });
+            return { signature };
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                const parsed = (0, anchor_1.translateError)(err, (0, anchor_1.parseIdlErrors)(this.programs.stakePoolProgram.idl));
+                if (parsed) {
+                    throw new common_1.ContractError(err, parsed.name, parsed.message);
+                }
+            }
+            throw err;
+        }
+    }
+}
+exports.default = SolanaStakingClient;
+function pk(address) {
+    return typeof address === "string" ? new web3_js_1.PublicKey(address) : address;
+}
+const prefix = "Assertion failed";
+function invariant(condition, message) {
+    if (condition) {
+        return;
+    }
+    const provided = typeof message === "function" ? message() : message;
+    const value = provided ? `${prefix}: ${provided}` : prefix;
+    throw new Error(value);
+}
+function getFilters(criteria, byteOffsets) {
+    return Object.entries(criteria).reduce((acc, [key, value]) => {
+        const criteriaKey = key;
+        const effectiveByteOffset = byteOffsets[criteriaKey];
+        if (criteria[criteriaKey] && effectiveByteOffset) {
+            acc.push({
+                memcmp: {
+                    offset: effectiveByteOffset,
+                    bytes: value.toString(),
+                },
+            });
+        }
+        return acc;
+    }, []);
+}

package/dist/cjs/solana/constants.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REWARD_POOL_PROGRAM_ID = exports.STAKE_POOL_PROGRAM_ID = exports.REWARD_ENTRY_BYTE_OFFSETS = exports.REWARD_ENTRY_STAKE_ENTRY_OFFSET = exports.REWARD_ENTRY_REWARD_POOL_OFFSET = exports.REWARD_POOL_BYTE_OFFSETS = exports.REWARD_POOL_MINT_OFFSET = exports.REWARD_POOL_STAKE_POOL_OFFSET = exports.STAKE_POOL_BYTE_OFFSETS = exports.STAKE_POOL_CREATOR_OFFSET = exports.STAKE_POOL_MINT_OFFSET = exports.STAKE_ENTRY_BYTE_OFFSETS = exports.STAKE_ENTRY_OWNER_OFFSET = exports.STAKE_ENTRY_STAKE_POOL_OFFSET = exports.ANCHOR_DISCRIMINATOR_OFFSET = exports.STREAMFLOW_TREASURY_PUBLIC_KEY = exports.FEE_VALUE_PREFIX = exports.CONFIG_PREFIX = exports.REWARD_ENTRY_PREFIX = exports.REWARD_VAULT_PREFIX = exports.REWARD_POOL_PREFIX = exports.STAKE_VAULT_PREFIX = exports.STAKE_MINT_PREFIX = exports.STAKE_POOL_PREFIX = exports.STAKE_ENTRY_PREFIX = exports.STAKE_ENTRY_DISCRIMINATOR = exports.U64_MAX = exports.SCALE_PRECISION_FACTOR_BN = exports.SCALE_PRECISION_FACTOR = exports.DEFAULT_FEE_BN = exports.DEFAULT_FEE = exports.FEE_PRECISION_FACTOR_BN = exports.FEE_PRECISION_FACTOR = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const common_1 = require("@streamflow/common");
+const web3_js_1 = require("@solana/web3.js");
+exports.FEE_PRECISION_FACTOR = 10000;
+exports.FEE_PRECISION_FACTOR_BN = new anchor_1.BN(exports.FEE_PRECISION_FACTOR);
+exports.DEFAULT_FEE = 99;
+exports.DEFAULT_FEE_BN = new anchor_1.BN(exports.DEFAULT_FEE);
+exports.SCALE_PRECISION_FACTOR = 1000000000;
+exports.SCALE_PRECISION_FACTOR_BN = new anchor_1.BN(exports.SCALE_PRECISION_FACTOR);
+exports.U64_MAX = 18446744073709551615n;
+exports.STAKE_ENTRY_DISCRIMINATOR = [187, 127, 9, 35, 155, 68, 86, 40];
+exports.STAKE_ENTRY_PREFIX = Buffer.from("stake-entry", "utf-8");
+exports.STAKE_POOL_PREFIX = Buffer.from("stake-pool", "utf-8");
+exports.STAKE_MINT_PREFIX = Buffer.from("stake-mint", "utf-8");
+exports.STAKE_VAULT_PREFIX = Buffer.from("stake-vault", "utf-8");
+exports.REWARD_POOL_PREFIX = Buffer.from("reward-pool", "utf-8");
+exports.REWARD_VAULT_PREFIX = Buffer.from("reward-vault", "utf-8");
+exports.REWARD_ENTRY_PREFIX = Buffer.from("reward-entry", "utf-8");
+exports.CONFIG_PREFIX = Buffer.from("config", "utf-8");
+exports.FEE_VALUE_PREFIX = Buffer.from("fee-value", "utf-8");
+exports.STREAMFLOW_TREASURY_PUBLIC_KEY = new web3_js_1.PublicKey("5SEpbdjFK5FxwTvfsGMXVQTD2v4M2c5tyRTxhdsPkgDw");
+exports.ANCHOR_DISCRIMINATOR_OFFSET = 8;
+exports.STAKE_ENTRY_STAKE_POOL_OFFSET = exports.ANCHOR_DISCRIMINATOR_OFFSET + 4;
+exports.STAKE_ENTRY_OWNER_OFFSET = exports.STAKE_ENTRY_STAKE_POOL_OFFSET + 32;
+exports.STAKE_ENTRY_BYTE_OFFSETS = {
+    payer: exports.STAKE_ENTRY_OWNER_OFFSET,
+    stakePool: exports.STAKE_ENTRY_STAKE_POOL_OFFSET,
+};
+exports.STAKE_POOL_MINT_OFFSET = exports.ANCHOR_DISCRIMINATOR_OFFSET + 8;
+exports.STAKE_POOL_CREATOR_OFFSET = exports.STAKE_POOL_MINT_OFFSET + 32;
+exports.STAKE_POOL_BYTE_OFFSETS = {
+    mint: exports.STAKE_POOL_MINT_OFFSET,
+    creator: exports.STAKE_POOL_CREATOR_OFFSET,
+};
+exports.REWARD_POOL_STAKE_POOL_OFFSET = exports.ANCHOR_DISCRIMINATOR_OFFSET + 2;
+exports.REWARD_POOL_MINT_OFFSET = exports.REWARD_POOL_STAKE_POOL_OFFSET + 32;
+exports.REWARD_POOL_BYTE_OFFSETS = {
+    stakePool: exports.REWARD_POOL_STAKE_POOL_OFFSET,
+    mint: exports.REWARD_POOL_MINT_OFFSET,
+};
+exports.REWARD_ENTRY_REWARD_POOL_OFFSET = exports.ANCHOR_DISCRIMINATOR_OFFSET;
+exports.REWARD_ENTRY_STAKE_ENTRY_OFFSET = exports.REWARD_ENTRY_REWARD_POOL_OFFSET + 32;
+exports.REWARD_ENTRY_BYTE_OFFSETS = {
+    stakeEntry: exports.REWARD_ENTRY_STAKE_ENTRY_OFFSET,
+    rewardPool: exports.REWARD_ENTRY_REWARD_POOL_OFFSET,
+};
+exports.STAKE_POOL_PROGRAM_ID = {
+    [common_1.ICluster.Mainnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+    [common_1.ICluster.Devnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+    [common_1.ICluster.Testnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+    [common_1.ICluster.Local]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+};
+exports.REWARD_POOL_PROGRAM_ID = {
+    [common_1.ICluster.Mainnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+    [common_1.ICluster.Devnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+    [common_1.ICluster.Testnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+    [common_1.ICluster.Local]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+};

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

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