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

package/dist/cjs/index.cjs

@@ -0,0 +1,2942 @@
+'use strict';
+
+var anchor = require('@coral-xyz/anchor');
+var splToken = require('@solana/spl-token');
+var web3_js = require('@solana/web3.js');
+var common = require('@streamflow/common');
+var solana = require('@streamflow/common/solana');
+var BN3 = require('bn.js');
+require('@solana/wallet-adapter-base');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var BN3__default = /*#__PURE__*/_interopDefault(BN3);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// solana/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ANCHOR_DISCRIMINATOR_OFFSET: () => ANCHOR_DISCRIMINATOR_OFFSET,
+  CONFIG_PREFIX: () => CONFIG_PREFIX,
+  DEFAULT_FEE: () => DEFAULT_FEE,
+  DEFAULT_FEE_BN: () => DEFAULT_FEE_BN,
+  FEE_PRECISION_FACTOR: () => FEE_PRECISION_FACTOR,
+  FEE_PRECISION_FACTOR_BN: () => FEE_PRECISION_FACTOR_BN,
+  FEE_PROGRAM_ID: () => FEE_PROGRAM_ID,
+  FEE_VALUE_PREFIX: () => FEE_VALUE_PREFIX,
+  REWARD_AMOUNT_DECIMALS: () => REWARD_AMOUNT_DECIMALS,
+  REWARD_AMOUNT_PRECISION_FACTOR: () => REWARD_AMOUNT_PRECISION_FACTOR,
+  REWARD_AMOUNT_PRECISION_FACTOR_BN: () => REWARD_AMOUNT_PRECISION_FACTOR_BN,
+  REWARD_ENTRY_BYTE_OFFSETS: () => REWARD_ENTRY_BYTE_OFFSETS,
+  REWARD_ENTRY_PREFIX: () => REWARD_ENTRY_PREFIX,
+  REWARD_ENTRY_REWARD_POOL_OFFSET: () => REWARD_ENTRY_REWARD_POOL_OFFSET,
+  REWARD_ENTRY_STAKE_ENTRY_OFFSET: () => REWARD_ENTRY_STAKE_ENTRY_OFFSET,
+  REWARD_POOL_BYTE_OFFSETS: () => REWARD_POOL_BYTE_OFFSETS,
+  REWARD_POOL_MINT_OFFSET: () => REWARD_POOL_MINT_OFFSET,
+  REWARD_POOL_PREFIX: () => REWARD_POOL_PREFIX,
+  REWARD_POOL_PROGRAM_ID: () => REWARD_POOL_PROGRAM_ID,
+  REWARD_POOL_STAKE_POOL_OFFSET: () => REWARD_POOL_STAKE_POOL_OFFSET,
+  REWARD_VAULT_PREFIX: () => REWARD_VAULT_PREFIX,
+  SCALE_PRECISION_FACTOR: () => SCALE_PRECISION_FACTOR,
+  SCALE_PRECISION_FACTOR_BN: () => SCALE_PRECISION_FACTOR_BN,
+  STAKE_ENTRY_BYTE_OFFSETS: () => STAKE_ENTRY_BYTE_OFFSETS,
+  STAKE_ENTRY_DISCRIMINATOR: () => STAKE_ENTRY_DISCRIMINATOR,
+  STAKE_ENTRY_OWNER_OFFSET: () => STAKE_ENTRY_OWNER_OFFSET,
+  STAKE_ENTRY_PAYER_OFFSET: () => STAKE_ENTRY_PAYER_OFFSET,
+  STAKE_ENTRY_PREFIX: () => STAKE_ENTRY_PREFIX,
+  STAKE_ENTRY_STAKE_POOL_OFFSET: () => STAKE_ENTRY_STAKE_POOL_OFFSET,
+  STAKE_MINT_PREFIX: () => STAKE_MINT_PREFIX,
+  STAKE_POOL_BYTE_OFFSETS: () => STAKE_POOL_BYTE_OFFSETS,
+  STAKE_POOL_CREATOR_OFFSET: () => STAKE_POOL_CREATOR_OFFSET,
+  STAKE_POOL_MINT_OFFSET: () => STAKE_POOL_MINT_OFFSET,
+  STAKE_POOL_PREFIX: () => STAKE_POOL_PREFIX,
+  STAKE_POOL_PROGRAM_ID: () => STAKE_POOL_PROGRAM_ID,
+  STAKE_VAULT_PREFIX: () => STAKE_VAULT_PREFIX,
+  STREAMFLOW_TREASURY_PUBLIC_KEY: () => STREAMFLOW_TREASURY_PUBLIC_KEY,
+  U64_MAX: () => U64_MAX
+});
+var FEE_PRECISION_FACTOR = 1e4;
+var FEE_PRECISION_FACTOR_BN = new BN3__default.default(FEE_PRECISION_FACTOR);
+var DEFAULT_FEE = 19;
+var DEFAULT_FEE_BN = new BN3__default.default(DEFAULT_FEE);
+var SCALE_PRECISION_FACTOR = 1e9;
+var SCALE_PRECISION_FACTOR_BN = new BN3__default.default(SCALE_PRECISION_FACTOR);
+var REWARD_AMOUNT_DECIMALS = 9;
+var REWARD_AMOUNT_PRECISION_FACTOR = 1e9;
+var REWARD_AMOUNT_PRECISION_FACTOR_BN = new BN3__default.default(REWARD_AMOUNT_PRECISION_FACTOR);
+var U64_MAX = 18446744073709551615n;
+var STAKE_ENTRY_DISCRIMINATOR = [187, 127, 9, 35, 155, 68, 86, 40];
+var STAKE_ENTRY_PREFIX = Buffer.from("stake-entry", "utf-8");
+var STAKE_POOL_PREFIX = Buffer.from("stake-pool", "utf-8");
+var STAKE_MINT_PREFIX = Buffer.from("stake-mint", "utf-8");
+var STAKE_VAULT_PREFIX = Buffer.from("stake-vault", "utf-8");
+var REWARD_POOL_PREFIX = Buffer.from("reward-pool", "utf-8");
+var REWARD_VAULT_PREFIX = Buffer.from("reward-vault", "utf-8");
+var REWARD_ENTRY_PREFIX = Buffer.from("reward-entry", "utf-8");
+var CONFIG_PREFIX = Buffer.from("config", "utf-8");
+var FEE_VALUE_PREFIX = Buffer.from("fee-value", "utf-8");
+var STREAMFLOW_TREASURY_PUBLIC_KEY = new web3_js.PublicKey("5SEpbdjFK5FxwTvfsGMXVQTD2v4M2c5tyRTxhdsPkgDw");
+var ANCHOR_DISCRIMINATOR_OFFSET = 8;
+var STAKE_ENTRY_STAKE_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 4;
+var STAKE_ENTRY_PAYER_OFFSET = STAKE_ENTRY_STAKE_POOL_OFFSET + 32;
+var STAKE_ENTRY_OWNER_OFFSET = STAKE_ENTRY_PAYER_OFFSET + 32;
+var STAKE_ENTRY_BYTE_OFFSETS = {
+  payer: STAKE_ENTRY_PAYER_OFFSET,
+  authority: STAKE_ENTRY_OWNER_OFFSET,
+  stakePool: STAKE_ENTRY_STAKE_POOL_OFFSET
+};
+var STAKE_POOL_MINT_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 2;
+var STAKE_POOL_CREATOR_OFFSET = STAKE_POOL_MINT_OFFSET + 32;
+var STAKE_POOL_BYTE_OFFSETS = {
+  mint: STAKE_POOL_MINT_OFFSET,
+  creator: STAKE_POOL_CREATOR_OFFSET
+};
+var REWARD_POOL_STAKE_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET + 2;
+var REWARD_POOL_MINT_OFFSET = REWARD_POOL_STAKE_POOL_OFFSET + 32;
+var REWARD_POOL_BYTE_OFFSETS = {
+  stakePool: REWARD_POOL_STAKE_POOL_OFFSET,
+  mint: REWARD_POOL_MINT_OFFSET
+};
+var REWARD_ENTRY_REWARD_POOL_OFFSET = ANCHOR_DISCRIMINATOR_OFFSET;
+var REWARD_ENTRY_STAKE_ENTRY_OFFSET = REWARD_ENTRY_REWARD_POOL_OFFSET + 32;
+var REWARD_ENTRY_BYTE_OFFSETS = {
+  stakeEntry: REWARD_ENTRY_STAKE_ENTRY_OFFSET,
+  rewardPool: REWARD_ENTRY_REWARD_POOL_OFFSET
+};
+var STAKE_POOL_PROGRAM_ID = {
+  [common.ICluster.Mainnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+  [common.ICluster.Devnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+  [common.ICluster.Testnet]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+  [common.ICluster.Local]: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH"
+};
+var REWARD_POOL_PROGRAM_ID = {
+  [common.ICluster.Mainnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+  [common.ICluster.Devnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+  [common.ICluster.Testnet]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+  [common.ICluster.Local]: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj"
+};
+var FEE_PROGRAM_ID = {
+  [common.ICluster.Mainnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+  [common.ICluster.Devnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+  [common.ICluster.Testnet]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+  [common.ICluster.Local]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V"
+};
+
+// solana/descriptor/idl/fee_manager.json
+var fee_manager_default = {
+  address: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
+  metadata: {
+    name: "fee_manager",
+    version: "1.0.0",
+    spec: "0.1.0",
+    description: "Stores Fees and other admin configuration for the Staking protocol"
+  },
+  instructions: [
+    {
+      name: "change_authority",
+      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: "new_authority"
+        }
+      ],
+      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: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "remove_fee",
+      discriminator: [190, 227, 105, 10, 30, 161, 81, 212],
+      accounts: [
+        {
+          name: "fee_value",
+          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: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "update_config",
+      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: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "streamflow_fee",
+          type: {
+            option: "u64"
+          }
+        }
+      ]
+    },
+    {
+      name: "write_fee",
+      discriminator: [80, 12, 148, 143, 16, 120, 24, 48],
+      accounts: [
+        {
+          name: "fee_value",
+          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: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "streamflow_fee",
+          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: 6e3,
+      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: "streamflow_fee",
+            docs: ["Default fee"],
+            type: "u64"
+          },
+          {
+            name: "_buffer_1",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          },
+          {
+            name: "_buffer_2",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          },
+          {
+            name: "_buffer_3",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "FeeValue",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "streamflow_fee",
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// solana/descriptor/idl/reward_pool.json
+var reward_pool_default = {
+  address: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
+  metadata: {
+    name: "reward_pool",
+    version: "1.0.0",
+    spec: "0.1.0",
+    description: "Program to manage Reward Pools for Stake Pools and claim rewards from them"
+  },
+  instructions: [
+    {
+      name: "change_authority",
+      discriminator: [50, 106, 66, 104, 99, 118, 145, 88],
+      accounts: [
+        {
+          name: "authority",
+          docs: ["Current Authority"],
+          writable: true,
+          signer: true,
+          relations: ["reward_pool"]
+        },
+        {
+          name: "new_authority"
+        },
+        {
+          name: "reward_pool",
+          docs: ["Stake Pool"],
+          writable: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "claim_rewards",
+      discriminator: [4, 144, 132, 71, 116, 23, 151, 80],
+      accounts: [
+        {
+          name: "reward_pool",
+          docs: ["Reward Pool"],
+          writable: true
+        },
+        {
+          name: "stake_entry",
+          docs: ["Stake Entry for which rewards are being claimed"]
+        },
+        {
+          name: "reward_entry",
+          docs: ["Reward Entry that stores metadata about claimed rewards"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [114, 101, 119, 97, 114, 100, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "reward_pool"
+              },
+              {
+                kind: "account",
+                path: "stake_entry"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault",
+          docs: ["Reward Pool Vault that stores tokens"],
+          writable: true,
+          relations: ["reward_pool"]
+        },
+        {
+          name: "to",
+          docs: ["Account to send the reward tokens to."],
+          writable: true
+        },
+        {
+          name: "claimant",
+          docs: ["Who is claiming the tokens."],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "mint",
+          docs: ["The mint to claim."],
+          relations: ["reward_pool"]
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "close_entry",
+      discriminator: [132, 26, 202, 145, 190, 37, 114, 67],
+      accounts: [
+        {
+          name: "reward_pool",
+          docs: ["Reward Pool"]
+        },
+        {
+          name: "stake_entry",
+          docs: ["Stake Entry for which rewards are being claimed"]
+        },
+        {
+          name: "reward_entry",
+          docs: ["Reward Entry that stores metadata about claimed rewards"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [114, 101, 119, 97, 114, 100, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "reward_pool"
+              },
+              {
+                kind: "account",
+                path: "stake_entry"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_entry",
+      discriminator: [248, 207, 142, 242, 66, 162, 150, 16],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: ["Original Stake Pool"],
+          relations: ["reward_pool", "stake_entry"]
+        },
+        {
+          name: "reward_pool",
+          docs: ["Reward Pool"]
+        },
+        {
+          name: "stake_entry",
+          docs: ["Stake Entry for which rewards are being claimed"]
+        },
+        {
+          name: "reward_entry",
+          docs: ["Reward Entry that stores metadata about claimed rewards"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [114, 101, 119, 97, 114, 100, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "reward_pool"
+              },
+              {
+                kind: "account",
+                path: "stake_entry"
+              }
+            ]
+          }
+        },
+        {
+          name: "payer",
+          docs: ["Rent payer"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_pool",
+      discriminator: [233, 146, 209, 142, 207, 104, 64, 188],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: ["Stake Pool to Which Reward Pool is being added"]
+        },
+        {
+          name: "reward_pool",
+          docs: ["Reward Pool to add"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [114, 101, 119, 97, 114, 100, 45, 112, 111, 111, 108]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint",
+          docs: ["Mint used for rewards"]
+        },
+        {
+          name: "vault",
+          docs: ["Escrow Account that will store the tokens"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [114, 101, 119, 97, 114, 100, 45, 118, 97, 117, 108, 116]
+              },
+              {
+                kind: "account",
+                path: "reward_pool"
+              }
+            ]
+          }
+        },
+        {
+          name: "creator",
+          docs: ["Reward Pool creator"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u8"
+        },
+        {
+          name: "reward_amount",
+          type: "u64"
+        },
+        {
+          name: "reward_period",
+          type: "u64"
+        },
+        {
+          name: "permissionless",
+          type: "bool"
+        },
+        {
+          name: "last_claim_period_opt",
+          type: {
+            option: "u64"
+          }
+        }
+      ]
+    },
+    {
+      name: "fund_pool",
+      discriminator: [36, 57, 233, 176, 181, 20, 87, 159],
+      accounts: [
+        {
+          name: "funder",
+          docs: ["Reward Pool funder"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "from",
+          docs: ["Token Account from which tokens will be transferred"],
+          writable: true
+        },
+        {
+          name: "vault",
+          docs: ["Reward Pool Vault that stores tokens"],
+          writable: true,
+          relations: ["reward_pool"]
+        },
+        {
+          name: "mint",
+          docs: ["Mint of reward tokens"],
+          relations: ["reward_pool"]
+        },
+        {
+          name: "reward_pool",
+          docs: ["Stake Pool"],
+          writable: true
+        },
+        {
+          name: "streamflow_treasury",
+          writable: true,
+          address: "5SEpbdjFK5FxwTvfsGMXVQTD2v4M2c5tyRTxhdsPkgDw"
+        },
+        {
+          name: "streamflow_treasury_tokens",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "streamflow_treasury"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "config",
+          docs: ["Fee Configuration"],
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [99, 111, 110, 102, 105, 103]
+              }
+            ],
+            program: {
+              kind: "account",
+              path: "fee_program"
+            }
+          }
+        },
+        {
+          name: "fee_value",
+          docs: ["Fee Value for the funder account"],
+          optional: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [102, 101, 101, 45, 118, 97, 108, 117, 101]
+              },
+              {
+                kind: "account",
+                path: "funder"
+              }
+            ],
+            program: {
+              kind: "account",
+              path: "fee_program"
+            }
+          }
+        },
+        {
+          name: "fee_program",
+          address: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V"
+        },
+        {
+          name: "token_program"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "update_pool",
+      discriminator: [239, 214, 170, 78, 36, 35, 30, 34],
+      accounts: [
+        {
+          name: "authority",
+          docs: ["Current Authority"],
+          writable: true,
+          signer: true,
+          relations: ["reward_pool"]
+        },
+        {
+          name: "stake_pool",
+          docs: ["Stake Pool to Which Reward Pool belongs"],
+          relations: ["reward_pool"]
+        },
+        {
+          name: "reward_pool",
+          docs: ["Reward Pool"],
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "reward_amount",
+          type: {
+            option: "u64"
+          }
+        },
+        {
+          name: "reward_period",
+          type: {
+            option: "u64"
+          }
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "Config",
+      discriminator: [155, 12, 170, 224, 30, 250, 204, 130]
+    },
+    {
+      name: "FeeValue",
+      discriminator: [10, 188, 89, 64, 4, 183, 231, 0]
+    },
+    {
+      name: "RewardEntry",
+      discriminator: [208, 191, 173, 14, 213, 84, 179, 162]
+    },
+    {
+      name: "RewardPool",
+      discriminator: [134, 121, 197, 211, 133, 154, 82, 32]
+    },
+    {
+      name: "StakeEntry",
+      discriminator: [187, 127, 9, 35, 155, 68, 86, 40]
+    },
+    {
+      name: "StakePool",
+      discriminator: [121, 34, 206, 21, 79, 127, 255, 28]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "ArithmeticError",
+      msg: "Arithmetic Error (overflow/underflow)"
+    },
+    {
+      code: 6001,
+      name: "InvalidRewardAmount",
+      msg: "Reward amount should be more than 0"
+    },
+    {
+      code: 6002,
+      name: "InvalidRewardPeriod",
+      msg: "Reward period should be more than 0"
+    },
+    {
+      code: 6003,
+      name: "Unauthorized",
+      msg: "Account is not authorized to execute this instruction"
+    },
+    {
+      code: 6004,
+      name: "OwnerMismatch",
+      msg: "Token account owner did not match intended owner"
+    },
+    {
+      code: 6005,
+      name: "InvalidRewardVault",
+      msg: "Provided Reward Vault is Invalid"
+    },
+    {
+      code: 6006,
+      name: "InvalidRewardEntry",
+      msg: "Provided Reward Entry is Invalid"
+    },
+    {
+      code: 6007,
+      name: "InvalidStakeEntry",
+      msg: "Provided Stake Entry is Invalid"
+    },
+    {
+      code: 6008,
+      name: "InvalidRewardPool",
+      msg: "Provided Reward Pool is Invalid"
+    },
+    {
+      code: 6009,
+      name: "InvalidMint",
+      msg: "Invalid Mint"
+    },
+    {
+      code: 6010,
+      name: "StakeEntryClosed",
+      msg: "Stake Entry is closed, rewards are not claimable anymore"
+    },
+    {
+      code: 6011,
+      name: "StakeEntryOpened",
+      msg: "Stake Entry is still opened, closing is not possible"
+    },
+    {
+      code: 6012,
+      name: "RewardPoolDrained",
+      msg: "Reward Pool does not have enough Rewards for Claiming"
+    },
+    {
+      code: 6013,
+      name: "UpdateTooSoon",
+      msg: "Repeated update can not happen sooner than the stake pool max duration"
+    },
+    {
+      code: 6014,
+      name: "InvalidLastClaimPeriod",
+      msg: "Invalid last claim period provided"
+    }
+  ],
+  types: [
+    {
+      name: "Config",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            docs: ["Fee Manager authority"],
+            type: "pubkey"
+          },
+          {
+            name: "streamflow_fee",
+            docs: ["Default fee"],
+            type: "u64"
+          },
+          {
+            name: "_buffer_1",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          },
+          {
+            name: "_buffer_2",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          },
+          {
+            name: "_buffer_3",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "FeeValue",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "streamflow_fee",
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "RewardEntry",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "reward_pool",
+            docs: ["Reward Pool"],
+            type: "pubkey"
+          },
+          {
+            name: "stake_entry",
+            docs: ["Stake Entry for which reward entry was initialized"],
+            type: "pubkey"
+          },
+          {
+            name: "created_ts",
+            docs: ["Timestamp when reward entry has been created"],
+            type: "u64"
+          },
+          {
+            name: "accounted_amount",
+            docs: ["Sum of accounted amounts, used to correctly issue rewards in case of precision loss"],
+            type: "u128"
+          },
+          {
+            name: "claimed_amount",
+            docs: ["Sum of already claimed rewards"],
+            type: "u64"
+          },
+          {
+            name: "last_accounted_ts",
+            docs: ["Timestamp when rewards have been claimed last time"],
+            type: "u64"
+          },
+          {
+            name: "last_reward_amount",
+            docs: ["Reward amount used on last claim or entry creation"],
+            type: "u64"
+          },
+          {
+            name: "last_reward_period",
+            docs: ["Reward Period used on last claim or entry creation"],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 32]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "RewardPool",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "bump",
+            docs: ["Bump Seed used to sign transactions"],
+            type: "u8"
+          },
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate pools for the same mint"],
+            type: "u8"
+          },
+          {
+            name: "stake_pool",
+            docs: ["Stake Pool for which Reward Pool was added"],
+            type: "pubkey"
+          },
+          {
+            name: "mint",
+            docs: ["Mint of Reward Pool"],
+            type: "pubkey"
+          },
+          {
+            name: "creator",
+            docs: ["Creator of the Pool"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Current authority"],
+            type: "pubkey"
+          },
+          {
+            name: "reward_amount",
+            docs: [
+              "Amount of rewards that will be distributed per effective stake",
+              "",
+              "Should be a fraction of a raw token amount which is 1 / 10^9,",
+              "i.e. `reward_amount` of `1_000_000_000` equals one raw token per effective stake"
+            ],
+            type: "u64"
+          },
+          {
+            name: "reward_period",
+            docs: ["Period of Rewards distribution in seconds"],
+            type: "u64"
+          },
+          {
+            name: "permissionless",
+            docs: ["Whether anyone can fund the Pool"],
+            type: "bool"
+          },
+          {
+            name: "last_reward_amount",
+            docs: ["`reward_amount` used before the last update"],
+            type: "u64"
+          },
+          {
+            name: "last_reward_period",
+            docs: ["`reward_period` used before the last update"],
+            type: "u64"
+          },
+          {
+            name: "last_amount_update_ts",
+            docs: ["Time when `reward_amount` was updated the last time"],
+            type: "u64"
+          },
+          {
+            name: "last_period_update_ts",
+            docs: ["Time when `reward_period` was updated the last time"],
+            type: "u64"
+          },
+          {
+            name: "vault",
+            docs: ["Escrow Account that stores reward tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "funded_amount",
+            docs: ["Total funded amount"],
+            type: "u64"
+          },
+          {
+            name: "claimed_amount",
+            docs: ["Total number of rewards claimed"],
+            type: "u64"
+          },
+          {
+            name: "created_ts",
+            docs: ["Time when Reward Pool was created"],
+            type: "u64"
+          },
+          {
+            name: "last_claim_period",
+            docs: ["For how much seconds after unstake user should be able to claim rewards"],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 48]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "StakeEntry",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate stakes for the same pool"],
+            type: "u32"
+          },
+          {
+            name: "stake_pool",
+            docs: ["Stake Pool for which tokens were staked"],
+            type: "pubkey"
+          },
+          {
+            name: "payer",
+            docs: ["Original Owner of Staked tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Authority of the Entry"],
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            docs: ["Amount of deposited funds"],
+            type: "u64"
+          },
+          {
+            name: "duration",
+            docs: ["Duration of the lockup"],
+            type: "u64"
+          },
+          {
+            name: "effective_amount",
+            docs: ["Effective Amount staked, does not equal to deposited amount, accounts for Stake Weight"],
+            type: "u128"
+          },
+          {
+            name: "created_ts",
+            docs: ["Timestamp when Deposit was made"],
+            type: "u64"
+          },
+          {
+            name: "closed_ts",
+            docs: ["Flag whether entry has been already unstaked"],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "StakePool",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "bump",
+            docs: ["Bump Seed used to sign transactions"],
+            type: "u8"
+          },
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate pools for the same mint"],
+            type: "u8"
+          },
+          {
+            name: "mint",
+            docs: ["Mint of the Stake Pool"],
+            type: "pubkey"
+          },
+          {
+            name: "creator",
+            docs: ["Initial Creator"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Current authority"],
+            type: "pubkey"
+          },
+          {
+            name: "min_weight",
+            docs: [
+              "The lowest weight awarded for staking, measured as a fraction of `1 / SCALE_FACTOR_BASE`.",
+              "For instance:",
+              "* `min_weight = 1 x SCALE_FACTOR_BASE` signifies a minimum multiplier of 1x for min staking duration",
+              "* `min_weight = 2 x SCALE_FACTOR_BASE` indicates a minimum multiplier of 2x for min staking duration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "max_weight",
+            docs: [
+              "The highest weight awarded for staking, measured as a fraction of `1 / SCALE_FACTOR_BASE`.",
+              "For instance:",
+              "* `max_weight = 1 x SCALE_FACTOR_BASE` signifies a max multiplier of 1x for max staking duration",
+              "* `max_weight = 2 x SCALE_FACTOR_BASE` indicates a max multiplier of 2x for max staking duration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "min_duration",
+            docs: ["Min Duration of stake in seconds"],
+            type: "u64"
+          },
+          {
+            name: "max_duration",
+            docs: ["Max Duration of stake in seconds, the more duration, the more weight the stake has"],
+            type: "u64"
+          },
+          {
+            name: "permissionless",
+            docs: ["Whether anyone can add Reward Pools or just admin"],
+            type: "bool"
+          },
+          {
+            name: "vault",
+            docs: ["Escrow Account that stores staked tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "stake_mint",
+            docs: ["Stake Mint, will be returned in exchange for stake tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "total_stake",
+            docs: ["Total number of Staked tokens"],
+            type: "u64"
+          },
+          {
+            name: "total_effective_stake",
+            docs: [
+              "Total staked tokens accounting for each stake weight, does not equal `total_stake`,",
+              "represents a sum of effective stake multiplied by 10^9 for precision"
+            ],
+            type: "u128"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// solana/descriptor/idl/stake_pool.json
+var stake_pool_default = {
+  address: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
+  metadata: {
+    name: "stake_pool",
+    version: "2.1.1",
+    spec: "0.1.0",
+    description: "Program to manage Stake Pools and stake/unstake tokens"
+  },
+  instructions: [
+    {
+      name: "change_authority",
+      discriminator: [50, 106, 66, 104, 99, 118, 145, 88],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: ["Stake Pool"],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: ["Current Authority"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "new_authority"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_lookup_table",
+      discriminator: [74, 26, 45, 214, 23, 155, 143, 153],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: ["Stake Pool"]
+        },
+        {
+          name: "lookup_table_link",
+          docs: ["Link that will store address of the actual Lookup Table"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [108, 111, 111, 107, 117, 112, 45, 116, 97, 98, 108, 101]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              },
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "lookup_table",
+          writable: true
+        },
+        {
+          name: "lookup_table_program",
+          address: "AddressLookupTab1e1111111111111111111111111"
+        },
+        {
+          name: "payer",
+          docs: ["Payer of the transaction"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u32"
+        },
+        {
+          name: "recent_slot",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "create_pool",
+      discriminator: [233, 146, 209, 142, 207, 104, 64, 188],
+      accounts: [
+        {
+          name: "stake_pool",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 112, 111, 111, 108]
+              },
+              {
+                kind: "account",
+                path: "mint"
+              },
+              {
+                kind: "account",
+                path: "creator"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "mint",
+          docs: ["Mint used for staking"]
+        },
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 118, 97, 117, 108, 116]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              }
+            ]
+          }
+        },
+        {
+          name: "stake_mint",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 109, 105, 110, 116]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              }
+            ]
+          }
+        },
+        {
+          name: "creator",
+          docs: ["Stake Pool creator"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u8"
+        },
+        {
+          name: "max_weight",
+          type: "u64"
+        },
+        {
+          name: "min_duration",
+          type: "u64"
+        },
+        {
+          name: "max_duration",
+          type: "u64"
+        },
+        {
+          name: "permissionless",
+          type: "bool"
+        },
+        {
+          name: "freeze_stake_mint",
+          type: {
+            option: "bool"
+          }
+        },
+        {
+          name: "unstake_period",
+          type: {
+            option: "u64"
+          }
+        }
+      ]
+    },
+    {
+      name: "migrate_entry",
+      discriminator: [239, 154, 55, 173, 110, 36, 188, 214],
+      accounts: [
+        {
+          name: "stake_pool_from",
+          docs: ["Stake Pool"],
+          writable: true,
+          address: "Cja9f8JFS6sTgBqSRZGBrA2HDbUj4MZUGdtRYruKTeJp"
+        },
+        {
+          name: "stake_pool_to",
+          docs: ["Stake Pool"],
+          writable: true,
+          address: "BXRBbWMkscNBZoBL4fgRk77GBUX9eVP4AendQEumtPi8"
+        },
+        {
+          name: "stake_entry_from",
+          docs: ["Entry that will store Stake Metadata"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "stake_pool_from"
+              },
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "stake_entry_to",
+          docs: ["Entry that will store Stake Metadata"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "stake_pool_to"
+              },
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "arg",
+                path: "new_nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_from",
+          docs: ["Stake Pool Vault that stores staked tokens"],
+          writable: true
+        },
+        {
+          name: "vault_to",
+          docs: ["Stake Pool Vault that stores staked tokens"],
+          writable: true
+        },
+        {
+          name: "to",
+          docs: ["Token Account to transfer Stake Mint tokens to"],
+          writable: true
+        },
+        {
+          name: "payer",
+          docs: ["Owner of the Token Account from which tokens will be staked"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority"
+        },
+        {
+          name: "mint",
+          docs: ["Original mint of staked tokens"],
+          writable: true,
+          relations: ["stake_pool_from", "stake_pool_to"]
+        },
+        {
+          name: "stake_mint_from",
+          docs: ["Mint of stake tokens that will be minted in return for staking"],
+          writable: true
+        },
+        {
+          name: "stake_mint_to",
+          docs: ["Mint of stake tokens that will be minted in return for staking"],
+          writable: true
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u32"
+        },
+        {
+          name: "new_nonce",
+          type: "u32"
+        }
+      ]
+    },
+    {
+      name: "request_unstake",
+      discriminator: [44, 154, 110, 253, 160, 202, 54, 34],
+      accounts: [
+        {
+          name: "stake_pool",
+          writable: true,
+          relations: ["stake_entry"]
+        },
+        {
+          name: "stake_entry",
+          docs: ["Entry that stores Stake Metadata"],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: ["Stake Entry Authority"],
+          writable: true,
+          signer: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "set_token_metadata_spl",
+      discriminator: [244, 162, 227, 218, 129, 5, 25, 253],
+      accounts: [
+        {
+          name: "authority",
+          docs: ["Stake Pool Authority"],
+          signer: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "stake_pool"
+        },
+        {
+          name: "stake_mint",
+          relations: ["stake_pool"]
+        },
+        {
+          name: "metadata_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [109, 101, 116, 97, 100, 97, 116, 97]
+              },
+              {
+                kind: "account",
+                path: "metadata_program"
+              },
+              {
+                kind: "account",
+                path: "stake_mint"
+              }
+            ],
+            program: {
+              kind: "account",
+              path: "metadata_program"
+            }
+          }
+        },
+        {
+          name: "metadata_program",
+          docs: ["MPL Program"],
+          address: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "rent",
+          address: "SysvarRent111111111111111111111111111111111"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "symbol",
+          type: "string"
+        },
+        {
+          name: "uri",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "set_token_metadata_t22",
+      discriminator: [239, 134, 91, 83, 196, 57, 120, 106],
+      accounts: [
+        {
+          name: "authority",
+          docs: ["Stake Pool Authority"],
+          signer: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "stake_pool"
+        },
+        {
+          name: "stake_mint",
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "token_program",
+          address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "symbol",
+          type: "string"
+        },
+        {
+          name: "uri",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "stake",
+      discriminator: [206, 176, 202, 18, 200, 209, 179, 108],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: ["Stake Pool"],
+          writable: true
+        },
+        {
+          name: "stake_entry",
+          docs: ["Entry that will store Stake Metadata"],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [115, 116, 97, 107, 101, 45, 101, 110, 116, 114, 121]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              },
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "from",
+          docs: ["Token Account from which stake tokens will be transferred"],
+          writable: true
+        },
+        {
+          name: "vault",
+          docs: ["Stake Pool Vault that stores staked tokens"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "to",
+          docs: ["Token Account to transfer Stake Mint tokens to"],
+          writable: true
+        },
+        {
+          name: "payer",
+          docs: ["Owner of the Token Account from which tokens will be staked"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority"
+        },
+        {
+          name: "mint",
+          docs: ["Original mint of staked tokens"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "stake_mint",
+          docs: ["Mint of stake tokens that will be minted in return for staking"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u32"
+        },
+        {
+          name: "amount",
+          type: "u64"
+        },
+        {
+          name: "duration",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "unstake",
+      discriminator: [90, 95, 107, 42, 205, 124, 50, 225],
+      accounts: [
+        {
+          name: "stake_pool",
+          writable: true,
+          relations: ["stake_entry"]
+        },
+        {
+          name: "stake_entry",
+          docs: ["Entry that stores Stake Metadata"],
+          writable: true
+        },
+        {
+          name: "from",
+          docs: ["Stake Mint Token account"],
+          writable: true
+        },
+        {
+          name: "vault",
+          docs: ["Escrow Account that stores Staked tokens"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "to",
+          docs: ["Token account to withdraw Staked tokens to"],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: ["Stake Entry Authority"],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "mint",
+          docs: ["Original mint of staked tokens"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "stake_mint",
+          docs: ["Stake Mint used to exchanged Staked tokens to"],
+          writable: true,
+          relations: ["stake_pool"]
+        },
+        {
+          name: "token_program"
+        }
+      ],
+      args: []
+    }
+  ],
+  accounts: [
+    {
+      name: "LookupTableLink",
+      discriminator: [133, 88, 187, 141, 1, 53, 72, 236]
+    },
+    {
+      name: "StakeEntry",
+      discriminator: [187, 127, 9, 35, 155, 68, 86, 40]
+    },
+    {
+      name: "StakePool",
+      discriminator: [121, 34, 206, 21, 79, 127, 255, 28]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "InvalidDuration",
+      msg: "Minimum duration must be less than the maximum"
+    },
+    {
+      code: 6001,
+      name: "InvalidWeight",
+      msg: "Weight should be more than minimum"
+    },
+    {
+      code: 6002,
+      name: "DurationTooShort",
+      msg: "Duration of staking can't be less than minimum duration of the pool"
+    },
+    {
+      code: 6003,
+      name: "InvalidStakeAmount",
+      msg: "Stake amount should be more than 0"
+    },
+    {
+      code: 6004,
+      name: "ArithmeticError",
+      msg: "Arithmetic Error (overflow/underflow)"
+    },
+    {
+      code: 6005,
+      name: "Unauthorized",
+      msg: "Account is not authorized to execute this instruction"
+    },
+    {
+      code: 6006,
+      name: "OwnerMismatch",
+      msg: "Token account owner did not match intended owner"
+    },
+    {
+      code: 6007,
+      name: "InvalidMint",
+      msg: "Provided Mint does not equal the Pool Mint"
+    },
+    {
+      code: 6008,
+      name: "InvalidStakeVault",
+      msg: "Provided Stake Vault does not equal the Pool Vault"
+    },
+    {
+      code: 6009,
+      name: "InvalidStakeMint",
+      msg: "Provided Stake Mint does not equal the Pool Stake Mint"
+    },
+    {
+      code: 6010,
+      name: "InvalidStakePool",
+      msg: "Provided Stake Pool does not equal the Entry Stake Pool"
+    },
+    {
+      code: 6011,
+      name: "InvalidPoolMint",
+      msg: "Provided Mint does not equal the Pool Mint"
+    },
+    {
+      code: 6012,
+      name: "ClosedStake",
+      msg: "Stake Entry is already closed and can't be used"
+    },
+    {
+      code: 6013,
+      name: "LockedStake",
+      msg: "Stake is locked, unstake is not possible"
+    },
+    {
+      code: 6014,
+      name: "UnsupportedTokenExtensions",
+      msg: "Mint has unsupported Token Extensions"
+    },
+    {
+      code: 6015,
+      name: "UnstakeRequestNotRequired",
+      msg: "Unstake request is not required"
+    },
+    {
+      code: 6016,
+      name: "UnstakeRequestRequired",
+      msg: "Stake pool has unstake period, request is required prior to unstake"
+    },
+    {
+      code: 6017,
+      name: "UnstakeTooEarly",
+      msg: "Unstake is not possible until unstake period has passed"
+    }
+  ],
+  types: [
+    {
+      name: "LookupTableLink",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate lookup tables for the same stake pool"],
+            type: "u32"
+          },
+          {
+            name: "stake_pool",
+            docs: ["Stake Pool for which tokens were staked"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Authority of the Entry"],
+            type: "pubkey"
+          },
+          {
+            name: "lookup_table",
+            docs: ["Pubkey of the address lookup table"],
+            type: "pubkey"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 64]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "StakeEntry",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate stakes for the same pool"],
+            type: "u32"
+          },
+          {
+            name: "stake_pool",
+            docs: ["Stake Pool for which tokens were staked"],
+            type: "pubkey"
+          },
+          {
+            name: "payer",
+            docs: ["Original Owner of Staked tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Authority of the Entry"],
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            docs: ["Amount of deposited funds"],
+            type: "u64"
+          },
+          {
+            name: "duration",
+            docs: ["Duration of the lockup"],
+            type: "u64"
+          },
+          {
+            name: "effective_amount",
+            docs: ["Effective Amount staked, does not equal to deposited amount, accounts for Stake Weight"],
+            type: "u128"
+          },
+          {
+            name: "created_ts",
+            docs: ["Timestamp when Deposit was made"],
+            type: "u64"
+          },
+          {
+            name: "closed_ts",
+            docs: ["Timestamp when entry has been closed"],
+            type: "u64"
+          },
+          {
+            name: "prior_total_effective_stake",
+            docs: ["Total effective stake at the time of staking"],
+            type: "u128"
+          },
+          {
+            name: "unstake_ts",
+            docs: ["Timestamp when unstake was requested, will be used in case `unstake_period` is set"],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 40]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "StakePool",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "bump",
+            docs: ["Bump Seed used to sign transactions"],
+            type: "u8"
+          },
+          {
+            name: "nonce",
+            docs: ["Nonce to differentiate pools for the same mint"],
+            type: "u8"
+          },
+          {
+            name: "mint",
+            docs: ["Mint of the Stake Pool"],
+            type: "pubkey"
+          },
+          {
+            name: "creator",
+            docs: ["Initial Creator"],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: ["Current authority"],
+            type: "pubkey"
+          },
+          {
+            name: "min_weight",
+            docs: [
+              "The lowest weight awarded for staking, measured as a fraction of `1 / SCALE_FACTOR_BASE`.",
+              "For instance:",
+              "* `min_weight = 1 x SCALE_FACTOR_BASE` signifies a minimum multiplier of 1x for min staking duration",
+              "* `min_weight = 2 x SCALE_FACTOR_BASE` indicates a minimum multiplier of 2x for min staking duration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "max_weight",
+            docs: [
+              "The highest weight awarded for staking, measured as a fraction of `1 / SCALE_FACTOR_BASE`.",
+              "For instance:",
+              "* `max_weight = 1 x SCALE_FACTOR_BASE` signifies a max multiplier of 1x for max staking duration",
+              "* `max_weight = 2 x SCALE_FACTOR_BASE` indicates a max multiplier of 2x for max staking duration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "min_duration",
+            docs: ["Min Duration of stake in seconds"],
+            type: "u64"
+          },
+          {
+            name: "max_duration",
+            docs: ["Max Duration of stake in seconds, the more duration, the more weight the stake has"],
+            type: "u64"
+          },
+          {
+            name: "permissionless",
+            docs: ["Whether anyone can add Reward Pools or just admin"],
+            type: "bool"
+          },
+          {
+            name: "vault",
+            docs: ["Escrow Account that stores staked tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "stake_mint",
+            docs: ["Stake Mint, will be returned in exchange for stake tokens"],
+            type: "pubkey"
+          },
+          {
+            name: "total_stake",
+            docs: ["Total number of Staked tokens"],
+            type: "u64"
+          },
+          {
+            name: "total_effective_stake",
+            docs: [
+              "Total staked tokens accounting for each stake weight, does not equal `total_stake`,",
+              "represents a sum of effective stake multiplied by 10^9 for precision"
+            ],
+            type: "u128"
+          },
+          {
+            name: "freeze_stake_mint",
+            docs: ["Whether we should freeze stake mint token accounts"],
+            type: "bool"
+          },
+          {
+            name: "unstake_period",
+            docs: [
+              "Period for unstaking, if set unstake at first should be requested, and the real unstake can only happen after this period"
+            ],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: ["Buffer for additional fields"],
+            type: {
+              array: ["u8", 55]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+var deriveStakePoolPDA = (programId, mint, authority, nonce) => {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [STAKE_POOL_PREFIX, mint.toBuffer(), authority.toBuffer(), new BN3__default.default(nonce).toArrayLike(Buffer, "le", 1)],
+    programId
+  )[0];
+};
+var deriveStakeVaultPDA = (programId, stakePool) => {
+  return web3_js.PublicKey.findProgramAddressSync([STAKE_VAULT_PREFIX, stakePool.toBuffer()], programId)[0];
+};
+var deriveStakeMintPDA = (programId, stakePool) => {
+  return web3_js.PublicKey.findProgramAddressSync([STAKE_MINT_PREFIX, stakePool.toBuffer()], programId)[0];
+};
+var deriveStakeEntryPDA = (programId, stakePool, authority, nonce) => {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [STAKE_ENTRY_PREFIX, stakePool.toBuffer(), authority.toBuffer(), new BN3__default.default(nonce).toArrayLike(Buffer, "le", 4)],
+    programId
+  )[0];
+};
+var deriveRewardPoolPDA = (programId, stakePool, mint, nonce) => {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [REWARD_POOL_PREFIX, stakePool.toBuffer(), mint.toBuffer(), new BN3__default.default(nonce).toArrayLike(Buffer, "le", 1)],
+    programId
+  )[0];
+};
+var deriveRewardVaultPDA = (programId, rewardPool) => {
+  return web3_js.PublicKey.findProgramAddressSync([REWARD_VAULT_PREFIX, rewardPool.toBuffer()], programId)[0];
+};
+var deriveRewardEntryPDA = (programId, rewardPool, stakeEntry) => {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [REWARD_ENTRY_PREFIX, rewardPool.toBuffer(), stakeEntry.toBuffer()],
+    programId
+  )[0];
+};
+var deriveConfigPDA = (programId) => {
+  return web3_js.PublicKey.findProgramAddressSync([CONFIG_PREFIX], programId)[0];
+};
+var deriveFeeValuePDA = (programId, target) => {
+  return web3_js.PublicKey.findProgramAddressSync([FEE_VALUE_PREFIX, target.toBuffer()], programId)[0];
+};
+
+// solana/client.ts
+var SolanaStakingClient = class {
+  constructor({
+    clusterUrl,
+    cluster = common.ICluster.Mainnet,
+    commitment = "confirmed",
+    programIds,
+    sendRate = 1,
+    sendThrottler
+  }) {
+    this.cluster = cluster;
+    this.commitment = commitment;
+    this.connection = new web3_js.Connection(clusterUrl, this.commitment);
+    this.sendThrottler = sendThrottler ?? solana.buildSendThrottler(sendRate);
+    const stakePoolIdl = {
+      ...stake_pool_default,
+      address: programIds?.stakePool ?? STAKE_POOL_PROGRAM_ID[cluster] ?? stake_pool_default.address
+    };
+    const rewardPoolIdl = {
+      ...reward_pool_default,
+      address: programIds?.rewardPool ?? REWARD_POOL_PROGRAM_ID[cluster] ?? reward_pool_default.address
+    };
+    const feeManagerIdl = {
+      ...fee_manager_default,
+      address: programIds?.feeManager ?? fee_manager_default.address
+    };
+    this.programs = {
+      stakePoolProgram: new anchor.Program(stakePoolIdl, {
+        connection: this.connection
+      }),
+      rewardPoolProgram: new anchor.Program(rewardPoolIdl, {
+        connection: this.connection
+      }),
+      feeManagerProgram: new anchor.Program(feeManagerIdl, {
+        connection: this.connection
+      })
+    };
+  }
+  getCurrentProgramId(programKey) {
+    const program = this.programs[programKey];
+    common.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(solana.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(solana.getFilters(criteria, STAKE_ENTRY_BYTE_OFFSETS));
+  }
+  async searchRewardPools(criteria = {}) {
+    const { rewardPoolProgram } = this.programs;
+    return rewardPoolProgram.account.rewardPool.all(solana.getFilters(criteria, REWARD_POOL_BYTE_OFFSETS));
+  }
+  async searchRewardEntries(criteria) {
+    const { rewardPoolProgram } = this.programs;
+    return rewardPoolProgram.account.rewardEntry.all(solana.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 web3_js.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 = splToken.TOKEN_PROGRAM_ID
+  }, extParams) {
+    const { stakePoolProgram } = this.programs;
+    const creator = extParams.invoker.publicKey;
+    common.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, solana.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 = splToken.TOKEN_PROGRAM_ID }, extParams) {
+    const { stakePoolProgram } = this.programs;
+    const staker = extParams.invoker.publicKey;
+    common.invariant(staker, "Undefined invoker publicKey");
+    const mint = deriveStakeMintPDA(stakePoolProgram.programId, solana.pk(stakePool));
+    const stakeMintAccountKey = splToken.getAssociatedTokenAddressSync(mint, staker, true, solana.pk(tokenProgramId));
+    const poolMintAccountKey = splToken.getAssociatedTokenAddressSync(solana.pk(stakePoolMint), staker, true, solana.pk(tokenProgramId));
+    const instruction = await stakePoolProgram.methods.stake(nonce, amount, duration).accounts({
+      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 = splToken.TOKEN_PROGRAM_ID }, extParams) {
+    const { stakePoolProgram } = this.programs;
+    const staker = extParams.invoker.publicKey;
+    common.invariant(staker, "Undefined invoker publicKey");
+    const stakeMintKey = deriveStakeMintPDA(stakePoolProgram.programId, solana.pk(stakePool));
+    const stakeEntryKey = deriveStakeEntryPDA(stakePoolProgram.programId, solana.pk(stakePool), staker, nonce);
+    const poolMintAccountKey = splToken.getAssociatedTokenAddressSync(solana.pk(stakePoolMint), staker, true, solana.pk(tokenProgramId));
+    const stakeMintAccountKey = splToken.getAssociatedTokenAddressSync(stakeMintKey, staker, true, solana.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 = splToken.TOKEN_PROGRAM_ID
+  }, extParams) {
+    const { rewardPoolProgram } = this.programs;
+    const creator = extParams.invoker.publicKey;
+    common.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, solana.pk(stakePool), solana.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 = splToken.TOKEN_PROGRAM_ID, rewardMint }, extParams) {
+    const { stakePoolProgram, rewardPoolProgram } = this.programs;
+    const staker = extParams.invoker.publicKey;
+    common.invariant(staker, "Undefined invoker publicKey");
+    const instruction = await rewardPoolProgram.methods.claimRewards().accounts({
+      stakeEntry: deriveStakeEntryPDA(stakePoolProgram.programId, solana.pk(stakePool), staker, depositNonce),
+      rewardPool: deriveRewardPoolPDA(rewardPoolProgram.programId, solana.pk(stakePool), solana.pk(rewardMint), rewardPoolNonce),
+      claimant: staker,
+      tokenProgram: tokenProgramId,
+      to: splToken.getAssociatedTokenAddressSync(solana.pk(rewardMint), staker, true, solana.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 = splToken.TOKEN_PROGRAM_ID, rewardMint, stakePool, feeValue, nonce }, extParams) {
+    const { rewardPoolProgram } = this.programs;
+    const staker = extParams.invoker.publicKey;
+    common.invariant(staker, "Undefined invoker publicKey");
+    const existingFee = await this.getFeeValueIfExists(staker);
+    const rewardMintPk = solana.pk(rewardMint);
+    const tokenProgramPk = solana.pk(tokenProgramId);
+    const treasuryATA = !existingFee || existingFee.streamflowFee.gtn(0) ? await solana.checkOrCreateAtaBatch(
+      this.connection,
+      [STREAMFLOW_TREASURY_PUBLIC_KEY],
+      rewardMintPk,
+      extParams.invoker,
+      tokenProgramPk
+    ) : null;
+    const rewardPoolPda = deriveRewardPoolPDA(rewardPoolProgram.programId, solana.pk(stakePool), rewardMintPk, nonce);
+    const instruction = await rewardPoolProgram.methods.fundPool(amount).accountsPartial({
+      funder: staker,
+      rewardPool: rewardPoolPda,
+      from: splToken.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;
+    common.invariant(staker, "Undefined invoker publicKey");
+    const instruction = await rewardPoolProgram.methods.createEntry().accounts({
+      payer: staker,
+      authority: staker,
+      stakeEntry: deriveStakeEntryPDA(stakePoolProgram.programId, solana.pk(stakePool), staker, depositNonce),
+      rewardPool: deriveRewardPoolPDA(rewardPoolProgram.programId, solana.pk(stakePool), solana.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;
+    common.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];
+    common.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];
+    common.invariant(decodingProgram, `Decoding program with key ${programKey} is not available`);
+    const accountEntity = decodingProgram.idl.accounts.find((acc) => acc.name === accountName);
+    common.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 solana.prepareTransaction(
+      this.connection,
+      solana.prepareBaseInstructions(this.connection, extParams).concat(ixs),
+      extParams.invoker.publicKey
+    );
+    try {
+      const signature = await solana.signAndExecuteTransaction(
+        this.connection,
+        extParams.invoker,
+        tx,
+        {
+          hash,
+          context,
+          commitment: this.getCommitment()
+        },
+        { sendThrottler: this.sendThrottler }
+      );
+      return { signature };
+    } catch (err) {
+      if (err instanceof Error) {
+        const parsed = anchor.translateError(
+          err,
+          anchor.parseIdlErrors(this.programs.stakePoolProgram.idl)
+          // TODO how to catch an error from a specific program?
+        );
+        if (parsed) {
+          throw new common.ContractError(err, parsed.name, parsed.message);
+        }
+      }
+      throw err;
+    }
+  }
+};
+var RewardEntryAccumulator = class {
+  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 BN3__default.default(0)) ? this.lastAccountedTs : stakedTs;
+    const secondsPassed = accountableTs.sub(lastAccountedTs);
+    if (secondsPassed.lt(rewardPeriod)) {
+      return new BN3__default.default(0);
+    }
+    const periodsPassed = secondsPassed.div(rewardPeriod);
+    const claimablePerEffectiveStake = periodsPassed.mul(rewardAmount);
+    return claimablePerEffectiveStake.mul(effectiveStakedAmount).div(SCALE_PRECISION_FACTOR_BN);
+  }
+  // Calculates claimable amount from accountable amount.
+  getClaimableAmount() {
+    const claimedAmount = this.claimedAmount.mul(REWARD_AMOUNT_PRECISION_FACTOR_BN);
+    const nonClaimedAmount = this.accountedAmount.sub(claimedAmount);
+    return nonClaimedAmount.div(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);
+  }
+};
+var createDefaultRewardEntry = (stakeEntry, rewardPool) => {
+  return {
+    stakeEntry: new web3_js.PublicKey(stakeEntry.publicKey),
+    rewardPool: new web3_js.PublicKey(rewardPool.publicKey),
+    createdTs: stakeEntry.account.createdTs,
+    lastAccountedTs: new BN3__default.default(0),
+    lastRewardAmount: new BN3__default.default(0),
+    lastRewardPeriod: new BN3__default.default(0),
+    accountedAmount: new BN3__default.default(0),
+    claimedAmount: new BN3__default.default(0),
+    buffer: []
+  };
+};
+var 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() / 1e3);
+  const stakedTs = rewardPool.createdTs ? BN3__default.default.max(stakeEntry.createdTs, rewardPool.createdTs) : stakeEntry.createdTs;
+  const claimableTs = stakeEntry.closedTs.gtn(0) ? stakeEntry.closedTs : new BN3__default.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 BN3__default.default(0);
+      secondUpdateTs = rewardPool.lastAmountUpdateTs;
+      rewardAmount = rewardEntryAccumulator.lastRewardAmount;
+      rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
+    } else {
+      firstUpdateTs = new BN3__default.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();
+};
+var calculateRewardRateFromAmount = (rewardAmount, stakeTokenDecimals, rewardTokenDecimals) => {
+  const decimals = rewardTokenDecimals + (REWARD_AMOUNT_DECIMALS - stakeTokenDecimals);
+  return common.getNumberFromBN(rewardAmount, decimals);
+};
+var calculateRewardAmountFromValue = (rewardTokenValue, stakeTokenDecimals) => {
+  const decimalsDiff = REWARD_AMOUNT_DECIMALS - stakeTokenDecimals;
+  if (decimalsDiff === 0) {
+    return rewardTokenValue;
+  }
+  const diffFactor = new BN3__default.default(10).pow(new BN3__default.default(Math.abs(decimalsDiff)));
+  if (decimalsDiff > 0) {
+    return rewardTokenValue.mul(diffFactor);
+  }
+  return rewardTokenValue.div(diffFactor);
+};
+var calculateRewardAmountFromRate = (rewardRate, stakeTokenDecimals, rewardTokenDecimals) => {
+  return calculateRewardAmountFromValue(common.getBN(rewardRate, rewardTokenDecimals), stakeTokenDecimals);
+};
+var calculateFeeAmount = (amount, fee = DEFAULT_FEE_BN) => {
+  if (fee.eq(FEE_PRECISION_FACTOR_BN)) {
+    return amount;
+  }
+  return amount.mul(fee).div(FEE_PRECISION_FACTOR_BN);
+};
+var 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;
+};
+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 = common.divCeilN(numerator, denominator);
+    const fee = rawPreFeeAmount - transferAmount;
+    transferAmount = rawPreFeeAmount;
+    feeCharged = fee > transferFee.maximumFee ? transferFee.maximumFee : fee;
+  }
+  return { transferAmount, feeCharged };
+}
+var calculateStakeWeight = (minDuration, maxDuration, maxWeight, duration) => {
+  const durationSpan = maxDuration.sub(minDuration);
+  if (durationSpan.eq(new BN3__default.default(0))) {
+    return SCALE_PRECISION_FACTOR_BN;
+  }
+  const durationExceedingMin = duration.sub(minDuration);
+  const normalizedWeight = durationExceedingMin.mul(SCALE_PRECISION_FACTOR_BN).div(durationSpan);
+  const weightDiff = maxWeight.sub(SCALE_PRECISION_FACTOR_BN);
+  return BN3__default.default.max(
+    SCALE_PRECISION_FACTOR_BN.add(normalizedWeight.mul(weightDiff).div(SCALE_PRECISION_FACTOR_BN)),
+    SCALE_PRECISION_FACTOR_BN
+  );
+};
+
+exports.RewardEntryAccumulator = RewardEntryAccumulator;
+exports.SolanaStakingClient = SolanaStakingClient;
+exports.calcRewards = calcRewards;
+exports.calculateAmountWithTransferFees = calculateAmountWithTransferFees;
+exports.calculateDecimalsShift = calculateDecimalsShift;
+exports.calculateFeeAmount = calculateFeeAmount;
+exports.calculateRewardAmountFromRate = calculateRewardAmountFromRate;
+exports.calculateRewardAmountFromValue = calculateRewardAmountFromValue;
+exports.calculateRewardRateFromAmount = calculateRewardRateFromAmount;
+exports.calculateStakeWeight = calculateStakeWeight;
+exports.constants = constants_exports;
+exports.deriveConfigPDA = deriveConfigPDA;
+exports.deriveFeeValuePDA = deriveFeeValuePDA;
+exports.deriveRewardEntryPDA = deriveRewardEntryPDA;
+exports.deriveRewardPoolPDA = deriveRewardPoolPDA;
+exports.deriveRewardVaultPDA = deriveRewardVaultPDA;
+exports.deriveStakeEntryPDA = deriveStakeEntryPDA;
+exports.deriveStakeMintPDA = deriveStakeMintPDA;
+exports.deriveStakePoolPDA = deriveStakePoolPDA;
+exports.deriveStakeVaultPDA = deriveStakeVaultPDA;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map