@streamflow/staking 8.7.0 → 8.8.0-alpha.p305.1e86aff

package/dist/esm/index.js

@@ -3,7 +3,7 @@ import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from '@solana/spl-tok
 import { PublicKey, Connection } from '@solana/web3.js';
 import { ICluster, invariant, ContractError, getNumberFromBN, getBN, divCeilN } from '@streamflow/common';
 import { buildSendThrottler, getFilters, pk, checkOrCreateAtaBatch, unwrapExecutionParams, createAndEstimateTransaction, prepareBaseInstructions, prepareTransaction, signAndExecuteTransaction } from '@streamflow/common/solana';
-import BN3 from 'bn.js';
+import BN4 from 'bn.js';
 import '@solana/wallet-adapter-base';
 
 var __defProp = Object.defineProperty;
@@ -56,14 +56,14 @@ __export(constants_exports, {
   U64_MAX: () => U64_MAX
 });
 var FEE_PRECISION_FACTOR = 1e4;
-var FEE_PRECISION_FACTOR_BN = new BN3(FEE_PRECISION_FACTOR);
+var FEE_PRECISION_FACTOR_BN = new BN4(FEE_PRECISION_FACTOR);
 var DEFAULT_FEE = 19;
-var DEFAULT_FEE_BN = new BN3(DEFAULT_FEE);
+var DEFAULT_FEE_BN = new BN4(DEFAULT_FEE);
 var SCALE_PRECISION_FACTOR = 1e9;
-var SCALE_PRECISION_FACTOR_BN = new BN3(SCALE_PRECISION_FACTOR);
+var SCALE_PRECISION_FACTOR_BN = new BN4(SCALE_PRECISION_FACTOR);
 var REWARD_AMOUNT_DECIMALS = 9;
 var REWARD_AMOUNT_PRECISION_FACTOR = 1e9;
-var REWARD_AMOUNT_PRECISION_FACTOR_BN = new BN3(REWARD_AMOUNT_PRECISION_FACTOR);
+var REWARD_AMOUNT_PRECISION_FACTOR_BN = new BN4(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");
@@ -128,12 +128,946 @@ var FEE_PROGRAM_ID = {
   [ICluster.Local]: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V"
 };
 
+// solana/descriptor/idl/governor.json
+var governor_default = {
+  address: "GVERNASJFxi8vjjJtwCKYQTeN51XsV1y2B1ap1GtKrKR",
+  metadata: {
+    name: "governor",
+    version: "2.3.0",
+    spec: "0.1.0",
+    description: "Governor program to allow users to vote with stake tokens"
+  },
+  instructions: [
+    {
+      name: "add_proposal",
+      discriminator: [
+        130,
+        139,
+        214,
+        107,
+        93,
+        13,
+        84,
+        152
+      ],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: [
+            "The stake pool associated with the governor"
+          ],
+          relations: [
+            "governor"
+          ]
+        },
+        {
+          name: "governor",
+          docs: [
+            "The governor to which the proposal is being added"
+          ],
+          writable: true
+        },
+        {
+          name: "proposal",
+          docs: [
+            "The new proposal account to be created"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  112,
+                  114,
+                  111,
+                  112,
+                  111,
+                  115,
+                  97,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "governor"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          docs: [
+            "Authority of the governor"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u32"
+        },
+        {
+          name: "text",
+          type: "string"
+        },
+        {
+          name: "options",
+          type: {
+            vec: "string"
+          }
+        },
+        {
+          name: "voting_start_ts",
+          type: "u64"
+        },
+        {
+          name: "voting_end_ts",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "change_authority",
+      discriminator: [
+        50,
+        106,
+        66,
+        104,
+        99,
+        118,
+        145,
+        88
+      ],
+      accounts: [
+        {
+          name: "governor",
+          docs: [
+            "Reward Pool"
+          ],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: [
+            "Current Authority"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "new_authority"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "create_governor",
+      discriminator: [
+        103,
+        30,
+        78,
+        252,
+        28,
+        128,
+        40,
+        3
+      ],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: [
+            "The stake pool for which the governor is being created"
+          ]
+        },
+        {
+          name: "governor",
+          docs: [
+            "The governor account to be created"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  103,
+                  111,
+                  118,
+                  101,
+                  114,
+                  110,
+                  111,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "stake_pool"
+              },
+              {
+                kind: "arg",
+                path: "nonce"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          docs: [
+            "Authority of the stake pool"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u8"
+        }
+      ]
+    },
+    {
+      name: "set_active_proposal",
+      discriminator: [
+        41,
+        14,
+        222,
+        18,
+        33,
+        232,
+        43,
+        82
+      ],
+      accounts: [
+        {
+          name: "governor",
+          docs: [
+            "The governor for which to set the active proposal"
+          ],
+          writable: true,
+          relations: [
+            "proposal"
+          ]
+        },
+        {
+          name: "proposal",
+          docs: [
+            "The proposal to set as active"
+          ],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: [
+            "Authority of the governor"
+          ],
+          signer: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "vote_on_proposal",
+      discriminator: [
+        188,
+        239,
+        13,
+        88,
+        119,
+        199,
+        251,
+        119
+      ],
+      accounts: [
+        {
+          name: "stake_pool",
+          docs: [
+            "Original Stake Pool"
+          ],
+          relations: [
+            "governor"
+          ]
+        },
+        {
+          name: "governor",
+          docs: [
+            "The governor account that manages the voting process"
+          ],
+          writable: true,
+          relations: [
+            "proposal"
+          ]
+        },
+        {
+          name: "proposal",
+          docs: [
+            "The proposal being voted on"
+          ]
+        },
+        {
+          name: "vote",
+          docs: [
+            "The vote account that will be created to record the vote"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  111,
+                  116,
+                  101
+                ]
+              },
+              {
+                kind: "account",
+                path: "proposal"
+              },
+              {
+                kind: "account",
+                path: "voter"
+              }
+            ]
+          }
+        },
+        {
+          name: "stake_mint_account",
+          docs: [
+            "The user's stake token account that holds the stake tokens"
+          ]
+        },
+        {
+          name: "voter",
+          docs: [
+            "The user who is voting"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "rent_sponsor",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  110,
+                  116,
+                  45,
+                  115,
+                  112,
+                  111,
+                  110,
+                  115,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "event_authority",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "program"
+        }
+      ],
+      args: [
+        {
+          name: "option_index",
+          type: "u8"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "Governor",
+      discriminator: [
+        37,
+        136,
+        44,
+        80,
+        68,
+        85,
+        213,
+        178
+      ]
+    },
+    {
+      name: "Proposal",
+      discriminator: [
+        26,
+        94,
+        189,
+        187,
+        116,
+        136,
+        53,
+        33
+      ]
+    },
+    {
+      name: "StakePool",
+      discriminator: [
+        121,
+        34,
+        206,
+        21,
+        79,
+        127,
+        255,
+        28
+      ]
+    },
+    {
+      name: "Vote",
+      discriminator: [
+        96,
+        91,
+        104,
+        57,
+        145,
+        35,
+        172,
+        155
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "VoteEvent",
+      discriminator: [
+        195,
+        71,
+        250,
+        105,
+        120,
+        119,
+        234,
+        134
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "ArithmeticError",
+      msg: "Arithmetic Error (overflow/underflow)"
+    },
+    {
+      code: 6001,
+      name: "Unauthorized",
+      msg: "Account is not authorized to execute this instruction"
+    },
+    {
+      code: 6002,
+      name: "InvalidStakeMint",
+      msg: "Provided Stake Mint does not equal the Pool Stake Mint"
+    },
+    {
+      code: 6003,
+      name: "InvalidStakePool",
+      msg: "Provided Stake Pool does not equal the Entry Stake Pool"
+    },
+    {
+      code: 6004,
+      name: "InvalidGovernor",
+      msg: "Provided Governor does not match the proposal Governor"
+    },
+    {
+      code: 6005,
+      name: "InvalidProposalText",
+      msg: "Invalid proposal text provided"
+    },
+    {
+      code: 6006,
+      name: "InvalidProposalOptions",
+      msg: "Invalid proposal options provided"
+    },
+    {
+      code: 6007,
+      name: "InvalidProposalDuration",
+      msg: "Invalid proposal duration"
+    },
+    {
+      code: 6008,
+      name: "ProposalAlreadyActive",
+      msg: "This proposal is already active"
+    },
+    {
+      code: 6009,
+      name: "VotingNotStarted",
+      msg: "Voting not started yet"
+    },
+    {
+      code: 6010,
+      name: "VotingEnded",
+      msg: "Voting has already ended"
+    },
+    {
+      code: 6011,
+      name: "InvalidOptionIndex",
+      msg: "Provided option is not a valid proposal option"
+    },
+    {
+      code: 6012,
+      name: "InsufficientStakeTokens",
+      msg: "Insufficient tokens for voting"
+    }
+  ],
+  types: [
+    {
+      name: "Governor",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "bump",
+            docs: [
+              "Bump Seed used to sign transactions"
+            ],
+            type: "u8"
+          },
+          {
+            name: "nonce",
+            docs: [
+              "Nonce to support multiple governors for the same pool"
+            ],
+            type: "u8"
+          },
+          {
+            name: "stake_pool",
+            docs: [
+              "Stake Pool for which Reward Pool was added"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "authority",
+            docs: [
+              "Authority of the Governor that can add proposals and set the current one"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "current_proposal",
+            docs: [
+              "Address of the current proposal"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "total_proposals",
+            docs: [
+              "Total number of created proposals"
+            ],
+            type: "u64"
+          },
+          {
+            name: "_buffer",
+            docs: [
+              "Buffer for additional fields"
+            ],
+            type: {
+              array: [
+                "u8",
+                128
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "Proposal",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "nonce",
+            docs: [
+              "Nonce used to derive proposal address"
+            ],
+            type: "u32"
+          },
+          {
+            name: "governor",
+            docs: [
+              "Stake Pool for which Reward Pool was added"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "text",
+            docs: [
+              "Text of the proposals we reserve up to 512 bytes (ascii symbols take 1 byte)"
+            ],
+            type: "string"
+          },
+          {
+            name: "options",
+            docs: [
+              "Potential options that will be used when answering, we reserve enough space for up to 8x32 = 256 ascii symbols in total"
+            ],
+            type: {
+              vec: "string"
+            }
+          },
+          {
+            name: "voting_start_ts",
+            docs: [
+              "Time when voting starts, 0 means that voting start immediately after proposal was created"
+            ],
+            type: "u64"
+          },
+          {
+            name: "voting_end_ts",
+            docs: [
+              "Time when voting ends, 0 means that voting will be possible anytime"
+            ],
+            type: "u64"
+          },
+          {
+            name: "created_ts",
+            docs: [
+              "Time when proposal was created"
+            ],
+            type: "u64"
+          },
+          {
+            name: "last_active_ts",
+            docs: [
+              "Last time when proposal was made active"
+            ],
+            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: "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: "total_stake_capped",
+            docs: [
+              "Whether amount of total staked tokens is limited by `remaining_total_stake` - stored as separate flag to not deal with `Option`"
+            ],
+            type: "bool"
+          },
+          {
+            name: "remaining_total_stake",
+            docs: [
+              "Remaining total amount of staked tokens (cumulative)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "expiry_ts",
+            docs: [
+              "Time when stake pool expires, staking is not possible after expiration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, stake entries will be unstaked after duration"
+            ],
+            type: "bool"
+          },
+          {
+            name: "_buffer",
+            docs: [
+              "Buffer for additional fields"
+            ],
+            type: {
+              array: [
+                "u8",
+                37
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "Vote",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "proposal",
+            docs: [
+              "Question to which vote was provided"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "voter",
+            docs: [
+              "Voter that voted on the proposal"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "option_index",
+            docs: [
+              "Index of the option used for voting"
+            ],
+            type: "u8"
+          },
+          {
+            name: "weight",
+            docs: [
+              "Weight of the vote, correspond to number of sTokens used"
+            ],
+            type: "u64"
+          },
+          {
+            name: "is_sponsored",
+            docs: [
+              "Whether the vote rent has been sponsored by the rent vault"
+            ],
+            type: "bool"
+          },
+          {
+            name: "_buffer",
+            docs: [
+              "Buffer for additional fields"
+            ],
+            type: {
+              array: [
+                "u8",
+                63
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      name: "VoteEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "governor",
+            type: "pubkey"
+          },
+          {
+            name: "proposal",
+            type: "pubkey"
+          },
+          {
+            name: "voter",
+            type: "pubkey"
+          },
+          {
+            name: "option_index",
+            type: "u8"
+          },
+          {
+            name: "value",
+            type: "u64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
 // solana/descriptor/idl/fee_manager.json
 var fee_manager_default = {
   address: "FEELzfBhsWXTNJX53zZcDVfRNoFYZQ6cZA3jLiGVL16V",
   metadata: {
     name: "fee_manager",
-    version: "2.2.0",
+    version: "2.3.0",
     spec: "0.1.0",
     description: "Stores Fees and other admin configuration for the Staking protocol"
   },
@@ -571,7 +1505,7 @@ var reward_pool_default = {
   address: "RWRDdfRbi3339VgKxTAXg4cjyniF7cbhNbMxZWiSKmj",
   metadata: {
     name: "reward_pool",
-    version: "2.2.0",
+    version: "2.3.0",
     spec: "0.1.0",
     description: "Program to manage Reward Pools for Stake Pools and claim rewards from them"
   },
@@ -716,6 +1650,225 @@ var reward_pool_default = {
       ],
       args: []
     },
+    {
+      name: "claim_rewards_as_worker",
+      discriminator: [
+        120,
+        246,
+        117,
+        149,
+        120,
+        210,
+        52,
+        193
+      ],
+      accounts: [
+        {
+          name: "reward_pool",
+          docs: [
+            "Reward Pool"
+          ],
+          writable: true
+        },
+        {
+          name: "stake_pool",
+          docs: [
+            "Stake Pool"
+          ],
+          writable: true,
+          relations: [
+            "reward_pool"
+          ]
+        },
+        {
+          name: "stake_entry",
+          docs: [
+            "Stake Entry for which rewards are being claimed"
+          ],
+          writable: true
+        },
+        {
+          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: "stake_vault",
+          writable: true
+        },
+        {
+          name: "to",
+          writable: true
+        },
+        {
+          name: "stake_mint_from",
+          writable: true
+        },
+        {
+          name: "claimant",
+          writable: true
+        },
+        {
+          name: "worker",
+          docs: [
+            "Auto unstake worker"
+          ],
+          writable: true,
+          signer: true,
+          address: "wdrwhnCv4pzW8beKsbPa4S2UDZrXenjg16KJdKSpb5u"
+        },
+        {
+          name: "mint",
+          docs: [
+            "The mint to claim."
+          ],
+          writable: true,
+          relations: [
+            "reward_pool"
+          ]
+        },
+        {
+          name: "stake_mint",
+          docs: [
+            "Mint for sTokens issued by the stake pool"
+          ],
+          writable: true
+        },
+        {
+          name: "stake_pool_program",
+          address: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "clawback",
+      discriminator: [
+        111,
+        92,
+        142,
+        79,
+        33,
+        234,
+        82,
+        27
+      ],
+      accounts: [
+        {
+          name: "reward_pool",
+          docs: [
+            "Reward Pool"
+          ],
+          writable: true
+        },
+        {
+          name: "stake_pool",
+          docs: [
+            "Stake Pool to Which Reward Pool belongs"
+          ],
+          relations: [
+            "reward_pool"
+          ]
+        },
+        {
+          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: "authority",
+          docs: [
+            "Current Authority"
+          ],
+          writable: true,
+          signer: true,
+          relations: [
+            "reward_pool"
+          ]
+        },
+        {
+          name: "mint",
+          docs: [
+            "The mint to claim."
+          ],
+          relations: [
+            "reward_pool"
+          ]
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
     {
       name: "close_entry",
       discriminator: [
@@ -1481,7 +2634,7 @@ var reward_pool_default = {
     {
       code: 6002,
       name: "InvalidRewardPeriod",
-      msg: "Reward period should be more than 0"
+      msg: "Reward period should be more than 0 and less or equal than staking duration if auto unstake is enabled"
     },
     {
       code: 6003,
@@ -1542,6 +2695,36 @@ var reward_pool_default = {
       code: 6014,
       name: "InvalidLastClaimPeriod",
       msg: "Invalid last claim period provided"
+    },
+    {
+      code: 6015,
+      name: "ClawbackNotPossible",
+      msg: "Clawback is not possible for the provided Stake Pool"
+    },
+    {
+      code: 6016,
+      name: "ClawbackTooEarly",
+      msg: "Clawback requested too early, wait for the Pool to expire and cooldown to pass"
+    },
+    {
+      code: 6017,
+      name: "UpdateNotPossible",
+      msg: "Reward pool can not be updated"
+    },
+    {
+      code: 6018,
+      name: "EntryCreationNotPossibleAfterUnlock",
+      msg: "Reward entry can not be created after stake has been unlocked for this reward pool"
+    },
+    {
+      code: 6019,
+      name: "RefundNotPossible",
+      msg: "Refund not possible for this reward entry"
+    },
+    {
+      code: 6020,
+      name: "PoolCreationLimited",
+      msg: "Pool creation limited, use nonce 0"
     }
   ],
   types: [
@@ -1844,6 +3027,13 @@ var reward_pool_default = {
             ],
             type: "u64"
           },
+          {
+            name: "clawed_back_ts",
+            docs: [
+              "Timestamp when reward pool was clawed back"
+            ],
+            type: "u64"
+          },
           {
             name: "_buffer",
             docs: [
@@ -1852,7 +3042,7 @@ var reward_pool_default = {
             type: {
               array: [
                 "u8",
-                48
+                40
               ]
             }
           }
@@ -1948,6 +3138,13 @@ var reward_pool_default = {
             ],
             type: "bool"
           },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, copied from the stake pool for use in instructions that don't require the stake pool account"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -1956,7 +3153,7 @@ var reward_pool_default = {
             type: {
               array: [
                 "u8",
-                39
+                38
               ]
             }
           }
@@ -2087,6 +3284,34 @@ var reward_pool_default = {
             ],
             type: "u64"
           },
+          {
+            name: "total_stake_capped",
+            docs: [
+              "Whether amount of total staked tokens is limited by `remaining_total_stake` - stored as separate flag to not deal with `Option`"
+            ],
+            type: "bool"
+          },
+          {
+            name: "remaining_total_stake",
+            docs: [
+              "Remaining total amount of staked tokens (cumulative)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "expiry_ts",
+            docs: [
+              "Time when stake pool expires, staking is not possible after expiration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, stake entries will be unstaked after duration"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -2095,7 +3320,7 @@ var reward_pool_default = {
             type: {
               array: [
                 "u8",
-                55
+                37
               ]
             }
           }
@@ -2110,7 +3335,7 @@ var reward_pool_dynamic_default = {
   address: "RWRDyfZa6Rk9UYi85yjYYfGmoUqffLqjo6vZdFawEez",
   metadata: {
     name: "reward_pool_dynamic",
-    version: "2.2.0",
+    version: "2.3.0",
     spec: "0.1.0",
     description: "Reward pools with dynamic rewards distribution"
   },
@@ -3623,6 +4848,13 @@ var reward_pool_dynamic_default = {
             ],
             type: "bool"
           },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, copied from the stake pool for use in instructions that don't require the stake pool account"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -3631,7 +4863,7 @@ var reward_pool_dynamic_default = {
             type: {
               array: [
                 "u8",
-                39
+                38
               ]
             }
           }
@@ -3762,6 +4994,34 @@ var reward_pool_dynamic_default = {
             ],
             type: "u64"
           },
+          {
+            name: "total_stake_capped",
+            docs: [
+              "Whether amount of total staked tokens is limited by `remaining_total_stake` - stored as separate flag to not deal with `Option`"
+            ],
+            type: "bool"
+          },
+          {
+            name: "remaining_total_stake",
+            docs: [
+              "Remaining total amount of staked tokens (cumulative)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "expiry_ts",
+            docs: [
+              "Time when stake pool expires, staking is not possible after expiration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, stake entries will be unstaked after duration"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -3770,7 +5030,7 @@ var reward_pool_dynamic_default = {
             type: {
               array: [
                 "u8",
-                55
+                37
               ]
             }
           }
@@ -3810,6 +5070,13 @@ var reward_pool_dynamic_default = {
             ],
             type: "u64"
           },
+          {
+            name: "is_sponsored",
+            docs: [
+              "Whether the vote rent has been sponsored by the rent vault"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -3818,7 +5085,7 @@ var reward_pool_dynamic_default = {
             type: {
               array: [
                 "u8",
-                64
+                63
               ]
             }
           }
@@ -3833,7 +5100,7 @@ var stake_pool_default = {
   address: "STAKEvGqQTtzJZH6BWDcbpzXXn2BBerPAgQ3EGLN2GH",
   metadata: {
     name: "stake_pool",
-    version: "2.2.0",
+    version: "2.3.0",
     spec: "0.1.0",
     description: "Program to manage Stake Pools and stake/unstake tokens"
   },
@@ -4188,6 +5455,174 @@ var stake_pool_default = {
         }
       ]
     },
+    {
+      name: "create_pool_v2",
+      discriminator: [
+        133,
+        27,
+        21,
+        38,
+        67,
+        86,
+        91,
+        132
+      ],
+      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: "bool"
+        },
+        {
+          name: "unstake_period",
+          type: "u64"
+        },
+        {
+          name: "max_total_stake_cumulative",
+          type: "u64"
+        },
+        {
+          name: "expiry_ts",
+          type: "u64"
+        },
+        {
+          name: "auto_unstake",
+          type: "bool"
+        }
+      ]
+    },
     {
       name: "migrate_entry",
       discriminator: [
@@ -4647,7 +6082,60 @@ var stake_pool_default = {
           docs: [
             "Token Account to transfer Stake Mint tokens to"
           ],
-          writable: true
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "stake_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: "payer",
@@ -4760,7 +6248,60 @@ var stake_pool_default = {
           docs: [
             "Stake Mint Token account"
           ],
-          writable: true
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "stake_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: "vault",
@@ -4844,6 +6385,154 @@ var stake_pool_default = {
           }
         }
       ]
+    },
+    {
+      name: "unstake_as_worker",
+      discriminator: [
+        18,
+        36,
+        224,
+        241,
+        46,
+        185,
+        228,
+        142
+      ],
+      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,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "authority"
+              },
+              {
+                kind: "account",
+                path: "token_program"
+              },
+              {
+                kind: "account",
+                path: "stake_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: "vault",
+          docs: [
+            "Escrow Account that stores Staked tokens"
+          ],
+          writable: true,
+          relations: [
+            "stake_pool"
+          ]
+        },
+        {
+          name: "to",
+          writable: true
+        },
+        {
+          name: "authority",
+          writable: true
+        },
+        {
+          name: "worker",
+          docs: [
+            "Auto unstake worker"
+          ],
+          writable: true,
+          signer: true,
+          address: "wdrwhnCv4pzW8beKsbPa4S2UDZrXenjg16KJdKSpb5u"
+        },
+        {
+          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: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "token_program"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
     }
   ],
   accounts: [
@@ -4891,7 +6580,7 @@ var stake_pool_default = {
     {
       code: 6e3,
       name: "InvalidDuration",
-      msg: "Minimum duration must be less than the maximum"
+      msg: "Minimum duration must be less than the maximum, maximum should be a realistic number of seconds"
     },
     {
       code: 6001,
@@ -4986,7 +6675,42 @@ var stake_pool_default = {
     {
       code: 6019,
       name: "InvalidMinDuration",
-      msg: "Minimum duration should be at least 1"
+      msg: "Minimum duration should be at least 1, for auto-unstake 7 days at least"
+    },
+    {
+      code: 6020,
+      name: "AutoUnstakeNotPossible",
+      msg: "Auto unstake is not possible with unstake period or with a permissionless pool"
+    },
+    {
+      code: 6021,
+      name: "InvalidExpiry",
+      msg: "Expiry can not be less than max duration"
+    },
+    {
+      code: 6022,
+      name: "StakePayerNotSupported",
+      msg: "Separate payer account is not supported when staking in a pool with auto-unstake"
+    },
+    {
+      code: 6023,
+      name: "StakeAmountExceedsMax",
+      msg: "Stake amount exceeds max total stake"
+    },
+    {
+      code: 6024,
+      name: "StakeDurationExceedsExpiry",
+      msg: "Stake duration exceeds stake pool expiry"
+    },
+    {
+      code: 6025,
+      name: "AccountDelegateRevoked",
+      msg: "Token account delegate has been revoked by staker, can't burn tokens"
+    },
+    {
+      code: 6026,
+      name: "RefundNotPossible",
+      msg: "Refund not possible for this stake entry"
     }
   ],
   types: [
@@ -5127,6 +6851,13 @@ var stake_pool_default = {
             ],
             type: "bool"
           },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, copied from the stake pool for use in instructions that don't require the stake pool account"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -5135,7 +6866,7 @@ var stake_pool_default = {
             type: {
               array: [
                 "u8",
-                39
+                38
               ]
             }
           }
@@ -5266,6 +6997,34 @@ var stake_pool_default = {
             ],
             type: "u64"
           },
+          {
+            name: "total_stake_capped",
+            docs: [
+              "Whether amount of total staked tokens is limited by `remaining_total_stake` - stored as separate flag to not deal with `Option`"
+            ],
+            type: "bool"
+          },
+          {
+            name: "remaining_total_stake",
+            docs: [
+              "Remaining total amount of staked tokens (cumulative)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "expiry_ts",
+            docs: [
+              "Time when stake pool expires, staking is not possible after expiration"
+            ],
+            type: "u64"
+          },
+          {
+            name: "auto_unstake",
+            docs: [
+              "Whether auto unstaking is enabled, stake entries will be unstaked after duration"
+            ],
+            type: "bool"
+          },
           {
             name: "_buffer",
             docs: [
@@ -5274,7 +7033,7 @@ var stake_pool_default = {
             type: {
               array: [
                 "u8",
-                55
+                37
               ]
             }
           }
@@ -5285,7 +7044,7 @@ var stake_pool_default = {
 };
 var deriveStakePoolPDA = (programId, mint, authority, nonce) => {
   return PublicKey.findProgramAddressSync(
-    [STAKE_POOL_PREFIX, mint.toBuffer(), authority.toBuffer(), new BN3(nonce).toArrayLike(Buffer, "le", 1)],
+    [STAKE_POOL_PREFIX, mint.toBuffer(), authority.toBuffer(), new BN4(nonce).toArrayLike(Buffer, "le", 1)],
     programId
   )[0];
 };
@@ -5297,13 +7056,13 @@ var deriveStakeMintPDA = (programId, stakePool) => {
 };
 var deriveStakeEntryPDA = (programId, stakePool, authority, nonce) => {
   return PublicKey.findProgramAddressSync(
-    [STAKE_ENTRY_PREFIX, stakePool.toBuffer(), authority.toBuffer(), new BN3(nonce).toArrayLike(Buffer, "le", 4)],
+    [STAKE_ENTRY_PREFIX, stakePool.toBuffer(), authority.toBuffer(), new BN4(nonce).toArrayLike(Buffer, "le", 4)],
     programId
   )[0];
 };
 var deriveRewardPoolPDA = (programId, stakePool, mint, nonce) => {
   return PublicKey.findProgramAddressSync(
-    [REWARD_POOL_PREFIX, stakePool.toBuffer(), mint.toBuffer(), new BN3(nonce).toArrayLike(Buffer, "le", 1)],
+    [REWARD_POOL_PREFIX, stakePool.toBuffer(), mint.toBuffer(), new BN4(nonce).toArrayLike(Buffer, "le", 1)],
     programId
   )[0];
 };
@@ -5356,6 +7115,10 @@ var SolanaStakingClient = class {
       ...fee_manager_default,
       address: programIds?.feeManager ?? fee_manager_default.address
     };
+    const governorIdl = {
+      ...governor_default,
+      address: programIds?.governor ?? governor_default.address
+    };
     this.programs = {
       stakePoolProgram: new Program(stakePoolIdl, {
         connection: this.connection
@@ -5368,6 +7131,9 @@ var SolanaStakingClient = class {
       }),
       feeManagerProgram: new Program(feeManagerIdl, {
         connection: this.connection
+      }),
+      governor: new Program(governorIdl, {
+        connection: this.connection
       })
     };
   }
@@ -5437,13 +7203,36 @@ var SolanaStakingClient = class {
     permissionless = false,
     freezeStakeMint = null,
     unstakePeriod = null,
+    maxTotalStakeCumulative,
+    expiryTs,
+    autoUnstake,
     nonce,
     tokenProgramId = TOKEN_PROGRAM_ID
   }, extParams) {
     const { stakePoolProgram } = this.programs;
     const creator = extParams.invoker.publicKey;
+    const v2ParamsSet = maxTotalStakeCumulative !== void 0 || expiryTs !== void 0 || autoUnstake !== void 0;
     invariant(creator, "Undefined invoker publicKey");
-    const createInstruction = await stakePoolProgram.methods.createPool(nonce, maxWeight, minDuration, maxDuration, permissionless, freezeStakeMint, unstakePeriod).accounts({
+    const createInstruction = await (v2ParamsSet ? stakePoolProgram.methods.createPoolV2(
+      nonce,
+      maxWeight,
+      minDuration,
+      maxDuration,
+      permissionless,
+      freezeStakeMint ?? false,
+      unstakePeriod ?? new BN4(0),
+      maxTotalStakeCumulative ?? new BN4(0),
+      expiryTs ?? new BN4(0),
+      autoUnstake ?? false
+    ) : stakePoolProgram.methods.createPool(
+      nonce,
+      maxWeight,
+      minDuration,
+      maxDuration,
+      permissionless,
+      freezeStakeMint,
+      unstakePeriod
+    )).accounts({
       creator,
       mint,
       tokenProgram: tokenProgramId
@@ -5499,14 +7288,11 @@ var SolanaStakingClient = class {
     const { stakePoolProgram } = this.programs;
     const staker = extParams.invoker.publicKey;
     invariant(staker, "Undefined invoker publicKey");
-    const mint = deriveStakeMintPDA(stakePoolProgram.programId, pk(stakePool));
-    const stakeMintAccountKey = getAssociatedTokenAddressSync(mint, staker, true, pk(tokenProgramId));
     const poolMintAccountKey = getAssociatedTokenAddressSync(pk(stakePoolMint), staker, true, pk(tokenProgramId));
     const instruction = await stakePoolProgram.methods.stake(nonce, amount, duration).accounts({
       stakePool,
       tokenProgram: tokenProgramId,
       from: poolMintAccountKey,
-      to: stakeMintAccountKey,
       authority: staker,
       payer: staker
     }).instruction();
@@ -5600,14 +7386,11 @@ var SolanaStakingClient = class {
     const { stakePoolProgram } = this.programs;
     const staker = extParams.invoker.publicKey;
     invariant(staker, "Undefined invoker publicKey");
-    const stakeMintKey = deriveStakeMintPDA(stakePoolProgram.programId, pk(stakePool));
     const stakeEntryKey = deriveStakeEntryPDA(stakePoolProgram.programId, pk(stakePool), staker, nonce);
     const poolMintAccountKey = getAssociatedTokenAddressSync(pk(stakePoolMint), staker, true, pk(tokenProgramId));
-    const stakeMintAccountKey = getAssociatedTokenAddressSync(stakeMintKey, staker, true, pk(tokenProgramId));
     const instruction = await stakePoolProgram.methods.unstake(shouldClose).accounts({
       stakeEntry: stakeEntryKey,
       to: poolMintAccountKey,
-      from: stakeMintAccountKey,
       authority: staker,
       tokenProgram: tokenProgramId
     }).instruction();
@@ -5894,10 +7677,10 @@ var RewardEntryAccumulator = class {
   }
   // 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(0)) ? this.lastAccountedTs : stakedTs;
+    const lastAccountedTs = this.lastAccountedTs.gt(new BN4(0)) ? this.lastAccountedTs : stakedTs;
     const secondsPassed = accountableTs.sub(lastAccountedTs);
     if (secondsPassed.lt(rewardPeriod)) {
-      return new BN3(0);
+      return new BN4(0);
     }
     const periodsPassed = secondsPassed.div(rewardPeriod);
     const claimablePerEffectiveStake = periodsPassed.mul(rewardAmount);
@@ -5931,11 +7714,11 @@ var createDefaultRewardEntry = (stakeEntry, rewardPool) => {
     stakeEntry: new PublicKey(stakeEntry.publicKey),
     rewardPool: new PublicKey(rewardPool.publicKey),
     createdTs: stakeEntry.account.createdTs,
-    lastAccountedTs: new BN3(0),
-    lastRewardAmount: new BN3(0),
-    lastRewardPeriod: new BN3(0),
-    accountedAmount: new BN3(0),
-    claimedAmount: new BN3(0),
+    lastAccountedTs: new BN4(0),
+    lastRewardAmount: new BN4(0),
+    lastRewardPeriod: new BN4(0),
+    accountedAmount: new BN4(0),
+    claimedAmount: new BN4(0),
     isSponsored: false,
     buffer: []
   };
@@ -5949,8 +7732,8 @@ var calcRewards = (rewardEntryAccount, stakeEntryAccount, rewardPoolAccount) =>
     throw new Error("InvalidRewardEntry");
   }
   const currTs = Math.floor(Date.now() / 1e3);
-  const stakedTs = rewardPool.createdTs ? BN3.max(stakeEntry.createdTs, rewardPool.createdTs) : stakeEntry.createdTs;
-  const claimableTs = stakeEntry.closedTs.gtn(0) ? stakeEntry.closedTs : new BN3(currTs);
+  const stakedTs = rewardPool.createdTs ? BN4.max(stakeEntry.createdTs, rewardPool.createdTs) : stakeEntry.createdTs;
+  const claimableTs = stakeEntry.closedTs.gtn(0) ? stakeEntry.closedTs : new BN4(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) {
@@ -5968,12 +7751,12 @@ var calcRewards = (rewardEntryAccount, stakeEntryAccount, rewardPoolAccount) =>
         rewardPeriod = rewardPool.rewardPeriod;
       }
     } else if (amountUpdated) {
-      firstUpdateTs = new BN3(0);
+      firstUpdateTs = new BN4(0);
       secondUpdateTs = rewardPool.lastAmountUpdateTs;
       rewardAmount = rewardEntryAccumulator.lastRewardAmount;
       rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
     } else {
-      firstUpdateTs = new BN3(0);
+      firstUpdateTs = new BN4(0);
       secondUpdateTs = rewardPool.lastPeriodUpdateTs;
       rewardAmount = rewardEntryAccumulator.lastRewardAmount;
       rewardPeriod = rewardEntryAccumulator.lastRewardPeriod;
@@ -6026,7 +7809,7 @@ var calculateRewardAmountFromValue = (rewardTokenValue, stakeTokenDecimals) => {
   if (decimalsDiff === 0) {
     return rewardTokenValue;
   }
-  const diffFactor = new BN3(10).pow(new BN3(Math.abs(decimalsDiff)));
+  const diffFactor = new BN4(10).pow(new BN4(Math.abs(decimalsDiff)));
   if (decimalsDiff > 0) {
     return rewardTokenValue.mul(diffFactor);
   }
@@ -6071,13 +7854,13 @@ async function calculateAmountWithTransferFees(connection, transferFeeConfig, tr
 }
 var calculateStakeWeight = (minDuration, maxDuration, maxWeight, duration) => {
   const durationSpan = maxDuration.sub(minDuration);
-  if (durationSpan.eq(new BN3(0))) {
+  if (durationSpan.eq(new BN4(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.max(
+  return BN4.max(
     SCALE_PRECISION_FACTOR_BN.add(normalizedWeight.mul(weightDiff).div(SCALE_PRECISION_FACTOR_BN)),
     SCALE_PRECISION_FACTOR_BN
   );