FIX: Avoid MAX CU during route ixs (#32)

+ route ix's now take `max_iterations` as a parameter to avoid max CU -
they will pick up where they left off
+ large test to test max values

clients/js/jito_tip_router/accounts/baseRewardRouter.ts

@@ -19,6 +19,8 @@ import {
   getArrayEncoder,
   getStructDecoder,
   getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
   getU64Decoder,
   getU64Encoder,
   getU8Decoder,
@@ -55,6 +57,8 @@ export type BaseRewardRouter = {
   rewardPool: bigint;
   rewardsProcessed: bigint;
   reserved: Array<number>;
+  lastNcnGroupIndex: number;
+  lastVoteIndex: number;
   baseFeeGroupRewards: Array<BaseRewardRouterRewards>;
   ncnFeeGroupRewards: Array<BaseRewardRouterRewards>;
   ncnFeeGroupRewardRoutes: Array<NcnRewardRoute>;
@@ -70,6 +74,8 @@ export type BaseRewardRouterArgs = {
   rewardPool: number | bigint;
   rewardsProcessed: number | bigint;
   reserved: Array<number>;
+  lastNcnGroupIndex: number;
+  lastVoteIndex: number;
   baseFeeGroupRewards: Array<BaseRewardRouterRewardsArgs>;
   ncnFeeGroupRewards: Array<BaseRewardRouterRewardsArgs>;
   ncnFeeGroupRewardRoutes: Array<NcnRewardRouteArgs>;
@@ -86,6 +92,8 @@ export function getBaseRewardRouterEncoder(): Encoder<BaseRewardRouterArgs> {
     ['rewardPool', getU64Encoder()],
     ['rewardsProcessed', getU64Encoder()],
     ['reserved', getArrayEncoder(getU8Encoder(), { size: 128 })],
+    ['lastNcnGroupIndex', getU8Encoder()],
+    ['lastVoteIndex', getU16Encoder()],
     [
       'baseFeeGroupRewards',
       getArrayEncoder(getBaseRewardRouterRewardsEncoder(), { size: 8 }),
@@ -112,6 +120,8 @@ export function getBaseRewardRouterDecoder(): Decoder<BaseRewardRouter> {
     ['rewardPool', getU64Decoder()],
     ['rewardsProcessed', getU64Decoder()],
     ['reserved', getArrayDecoder(getU8Decoder(), { size: 128 })],
+    ['lastNcnGroupIndex', getU8Decoder()],
+    ['lastVoteIndex', getU16Decoder()],
     [
       'baseFeeGroupRewards',
       getArrayDecoder(getBaseRewardRouterRewardsDecoder(), { size: 8 }),

clients/js/jito_tip_router/accounts/ncnRewardRouter.ts

@@ -19,6 +19,8 @@ import {
   getArrayEncoder,
   getStructDecoder,
   getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
   getU64Decoder,
   getU64Encoder,
   getU8Decoder,
@@ -58,6 +60,8 @@ export type NcnRewardRouter = {
   rewardsProcessed: bigint;
   operatorRewards: bigint;
   reserved: Array<number>;
+  lastRewardsToProcess: bigint;
+  lastVaultOperatorDelegationIndex: number;
   vaultRewardRoutes: Array<VaultRewardRoute>;
 };
 
@@ -74,6 +78,8 @@ export type NcnRewardRouterArgs = {
   rewardsProcessed: number | bigint;
   operatorRewards: number | bigint;
   reserved: Array<number>;
+  lastRewardsToProcess: number | bigint;
+  lastVaultOperatorDelegationIndex: number;
   vaultRewardRoutes: Array<VaultRewardRouteArgs>;
 };
 
@@ -91,6 +97,8 @@ export function getNcnRewardRouterEncoder(): Encoder<NcnRewardRouterArgs> {
     ['rewardsProcessed', getU64Encoder()],
     ['operatorRewards', getU64Encoder()],
     ['reserved', getArrayEncoder(getU8Encoder(), { size: 128 })],
+    ['lastRewardsToProcess', getU64Encoder()],
+    ['lastVaultOperatorDelegationIndex', getU16Encoder()],
     [
       'vaultRewardRoutes',
       getArrayEncoder(getVaultRewardRouteEncoder(), { size: 64 }),
@@ -112,6 +120,8 @@ export function getNcnRewardRouterDecoder(): Decoder<NcnRewardRouter> {
     ['rewardsProcessed', getU64Decoder()],
     ['operatorRewards', getU64Decoder()],
     ['reserved', getArrayDecoder(getU8Decoder(), { size: 128 })],
+    ['lastRewardsToProcess', getU64Decoder()],
+    ['lastVaultOperatorDelegationIndex', getU16Decoder()],
     [
       'vaultRewardRoutes',
       getArrayDecoder(getVaultRewardRouteDecoder(), { size: 64 }),

clients/js/jito_tip_router/errors/jitoTipRouter.ts

@@ -154,10 +154,12 @@ export const JITO_TIP_ROUTER_ERROR__BAD_SWITCHBOARD_VALUE = 0x223a; // 8762
 export const JITO_TIP_ROUTER_ERROR__STALE_SWITCHBOARD_FEED = 0x223b; // 8763
 /** NoFeedWeightOrSwitchboardFeed: Weight entry needs either a feed or a no feed weight */
 export const JITO_TIP_ROUTER_ERROR__NO_FEED_WEIGHT_OR_SWITCHBOARD_FEED = 0x223c; // 8764
+/** RouterStillRouting: Router still routing */
+export const JITO_TIP_ROUTER_ERROR__ROUTER_STILL_ROUTING = 0x223d; // 8765
 /** InvalidEpochsBeforeStall: Invalid epochs before stall */
-export const JITO_TIP_ROUTER_ERROR__INVALID_EPOCHS_BEFORE_STALL = 0x223d; // 8765
+export const JITO_TIP_ROUTER_ERROR__INVALID_EPOCHS_BEFORE_STALL = 0x223e; // 8766
 /** InvalidSlotsAfterConsensus: Invalid slots after consensus */
-export const JITO_TIP_ROUTER_ERROR__INVALID_SLOTS_AFTER_CONSENSUS = 0x223e; // 8766
+export const JITO_TIP_ROUTER_ERROR__INVALID_SLOTS_AFTER_CONSENSUS = 0x223f; // 8767
 
 export type JitoTipRouterError =
   | typeof JITO_TIP_ROUTER_ERROR__ARITHMETIC_FLOOR_ERROR
@@ -211,6 +213,7 @@ export type JitoTipRouterError =
   | typeof JITO_TIP_ROUTER_ERROR__OPERATOR_REWARD_NOT_FOUND
   | typeof JITO_TIP_ROUTER_ERROR__OPERATOR_VOTES_FULL
   | typeof JITO_TIP_ROUTER_ERROR__REGISTRY_NOT_INITIALIZED
+  | typeof JITO_TIP_ROUTER_ERROR__ROUTER_STILL_ROUTING
   | typeof JITO_TIP_ROUTER_ERROR__STALE_SWITCHBOARD_FEED
   | typeof JITO_TIP_ROUTER_ERROR__SWITCHBOARD_NOT_REGISTERED
   | typeof JITO_TIP_ROUTER_ERROR__TABLE_NOT_INITIALIZED
@@ -287,6 +290,7 @@ if (process.env.NODE_ENV !== 'production') {
     [JITO_TIP_ROUTER_ERROR__OPERATOR_REWARD_NOT_FOUND]: `Operator Reward not found`,
     [JITO_TIP_ROUTER_ERROR__OPERATOR_VOTES_FULL]: `Operator votes full`,
     [JITO_TIP_ROUTER_ERROR__REGISTRY_NOT_INITIALIZED]: `Registry not initialized`,
+    [JITO_TIP_ROUTER_ERROR__ROUTER_STILL_ROUTING]: `Router still routing`,
     [JITO_TIP_ROUTER_ERROR__STALE_SWITCHBOARD_FEED]: `Stale switchboard feed`,
     [JITO_TIP_ROUTER_ERROR__SWITCHBOARD_NOT_REGISTERED]: `Switchboard not registered`,
     [JITO_TIP_ROUTER_ERROR__TABLE_NOT_INITIALIZED]: `Table not initialized`,

clients/js/jito_tip_router/instructions/routeBaseRewards.ts

@@ -10,6 +10,8 @@ import {
   combineCodec,
   getStructDecoder,
   getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
   getU64Decoder,
   getU64Encoder,
   getU8Decoder,
@@ -74,15 +76,20 @@ export type RouteBaseRewardsInstruction<
 
 export type RouteBaseRewardsInstructionData = {
   discriminator: number;
+  maxIterations: number;
   epoch: bigint;
 };
 
-export type RouteBaseRewardsInstructionDataArgs = { epoch: number | bigint };
+export type RouteBaseRewardsInstructionDataArgs = {
+  maxIterations: number;
+  epoch: number | bigint;
+};
 
 export function getRouteBaseRewardsInstructionDataEncoder(): Encoder<RouteBaseRewardsInstructionDataArgs> {
   return transformEncoder(
     getStructEncoder([
       ['discriminator', getU8Encoder()],
+      ['maxIterations', getU16Encoder()],
       ['epoch', getU64Encoder()],
     ]),
     (value) => ({ ...value, discriminator: ROUTE_BASE_REWARDS_DISCRIMINATOR })
@@ -92,6 +99,7 @@ export function getRouteBaseRewardsInstructionDataEncoder(): Encoder<RouteBaseRe
 export function getRouteBaseRewardsInstructionDataDecoder(): Decoder<RouteBaseRewardsInstructionData> {
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
+    ['maxIterations', getU16Decoder()],
     ['epoch', getU64Decoder()],
   ]);
 }
@@ -122,6 +130,7 @@ export type RouteBaseRewardsInput<
   baseRewardRouter: Address<TAccountBaseRewardRouter>;
   baseRewardReceiver: Address<TAccountBaseRewardReceiver>;
   restakingProgram: Address<TAccountRestakingProgram>;
+  maxIterations: RouteBaseRewardsInstructionDataArgs['maxIterations'];
   epoch: RouteBaseRewardsInstructionDataArgs['epoch'];
 };
 

clients/js/jito_tip_router/instructions/routeNcnRewards.ts

@@ -10,6 +10,8 @@ import {
   combineCodec,
   getStructDecoder,
   getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
   getU64Decoder,
   getU64Encoder,
   getU8Decoder,
@@ -75,11 +77,13 @@ export type RouteNcnRewardsInstruction<
 export type RouteNcnRewardsInstructionData = {
   discriminator: number;
   ncnFeeGroup: number;
+  maxIterations: number;
   epoch: bigint;
 };
 
 export type RouteNcnRewardsInstructionDataArgs = {
   ncnFeeGroup: number;
+  maxIterations: number;
   epoch: number | bigint;
 };
 
@@ -88,6 +92,7 @@ export function getRouteNcnRewardsInstructionDataEncoder(): Encoder<RouteNcnRewa
     getStructEncoder([
       ['discriminator', getU8Encoder()],
       ['ncnFeeGroup', getU8Encoder()],
+      ['maxIterations', getU16Encoder()],
       ['epoch', getU64Encoder()],
     ]),
     (value) => ({ ...value, discriminator: ROUTE_NCN_REWARDS_DISCRIMINATOR })
@@ -98,6 +103,7 @@ export function getRouteNcnRewardsInstructionDataDecoder(): Decoder<RouteNcnRewa
   return getStructDecoder([
     ['discriminator', getU8Decoder()],
     ['ncnFeeGroup', getU8Decoder()],
+    ['maxIterations', getU16Decoder()],
     ['epoch', getU64Decoder()],
   ]);
 }
@@ -129,6 +135,7 @@ export type RouteNcnRewardsInput<
   ncnRewardReceiver: Address<TAccountNcnRewardReceiver>;
   restakingProgram: Address<TAccountRestakingProgram>;
   ncnFeeGroup: RouteNcnRewardsInstructionDataArgs['ncnFeeGroup'];
+  maxIterations: RouteNcnRewardsInstructionDataArgs['maxIterations'];
   epoch: RouteNcnRewardsInstructionDataArgs['epoch'];
 };
 

clients/rust/jito_tip_router/src/generated/accounts/base_reward_router.rs

@@ -26,6 +26,8 @@ pub struct BaseRewardRouter {
     pub rewards_processed: u64,
     #[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]
     pub reserved: [u8; 128],
+    pub last_ncn_group_index: u8,
+    pub last_vote_index: u16,
     pub base_fee_group_rewards: [BaseRewardRouterRewards; 8],
     pub ncn_fee_group_rewards: [BaseRewardRouterRewards; 8],
     #[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]

clients/rust/jito_tip_router/src/generated/accounts/ncn_reward_router.rs

@@ -33,6 +33,8 @@ pub struct NcnRewardRouter {
     pub operator_rewards: u64,
     #[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]
     pub reserved: [u8; 128],
+    pub last_rewards_to_process: u64,
+    pub last_vault_operator_delegation_index: u16,
     #[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]
     pub vault_reward_routes: [VaultRewardRoute; 64],
 }

clients/rust/jito_tip_router/src/generated/errors/jito_tip_router.rs

@@ -219,12 +219,15 @@ pub enum JitoTipRouterError {
     /// 8764 - Weight entry needs either a feed or a no feed weight
     #[error("Weight entry needs either a feed or a no feed weight")]
     NoFeedWeightOrSwitchboardFeed = 0x223C,
-    /// 8765 - Invalid epochs before stall
+    /// 8765 - Router still routing
+    #[error("Router still routing")]
+    RouterStillRouting = 0x223D,
+    /// 8766 - Invalid epochs before stall
     #[error("Invalid epochs before stall")]
-    InvalidEpochsBeforeStall = 0x223D,
-    /// 8766 - Invalid slots after consensus
+    InvalidEpochsBeforeStall = 0x223E,
+    /// 8767 - Invalid slots after consensus
     #[error("Invalid slots after consensus")]
-    InvalidSlotsAfterConsensus = 0x223E,
+    InvalidSlotsAfterConsensus = 0x223F,
 }
 
 impl solana_program::program_error::PrintProgramError for JitoTipRouterError {

clients/rust/jito_tip_router/src/generated/instructions/route_base_rewards.rs

@@ -97,6 +97,7 @@ impl Default for RouteBaseRewardsInstructionData {
 #[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct RouteBaseRewardsInstructionArgs {
+    pub max_iterations: u16,
     pub epoch: u64,
 }
 
@@ -120,6 +121,7 @@ pub struct RouteBaseRewardsBuilder {
     base_reward_router: Option<solana_program::pubkey::Pubkey>,
     base_reward_receiver: Option<solana_program::pubkey::Pubkey>,
     restaking_program: Option<solana_program::pubkey::Pubkey>,
+    max_iterations: Option<u16>,
     epoch: Option<u64>,
     __remaining_accounts: Vec<solana_program::instruction::AccountMeta>,
 }
@@ -176,6 +178,11 @@ impl RouteBaseRewardsBuilder {
         self
     }
     #[inline(always)]
+    pub fn max_iterations(&mut self, max_iterations: u16) -> &mut Self {
+        self.max_iterations = Some(max_iterations);
+        self
+    }
+    #[inline(always)]
     pub fn epoch(&mut self, epoch: u64) -> &mut Self {
         self.epoch = Some(epoch);
         self
@@ -216,6 +223,10 @@ impl RouteBaseRewardsBuilder {
                 .expect("restaking_program is not set"),
         };
         let args = RouteBaseRewardsInstructionArgs {
+            max_iterations: self
+                .max_iterations
+                .clone()
+                .expect("max_iterations is not set"),
             epoch: self.epoch.clone().expect("epoch is not set"),
         };
 
@@ -406,6 +417,7 @@ impl<'a, 'b> RouteBaseRewardsCpiBuilder<'a, 'b> {
             base_reward_router: None,
             base_reward_receiver: None,
             restaking_program: None,
+            max_iterations: None,
             epoch: None,
             __remaining_accounts: Vec::new(),
         });
@@ -465,6 +477,11 @@ impl<'a, 'b> RouteBaseRewardsCpiBuilder<'a, 'b> {
         self
     }
     #[inline(always)]
+    pub fn max_iterations(&mut self, max_iterations: u16) -> &mut Self {
+        self.instruction.max_iterations = Some(max_iterations);
+        self
+    }
+    #[inline(always)]
     pub fn epoch(&mut self, epoch: u64) -> &mut Self {
         self.instruction.epoch = Some(epoch);
         self
@@ -511,6 +528,11 @@ impl<'a, 'b> RouteBaseRewardsCpiBuilder<'a, 'b> {
         signers_seeds: &[&[&[u8]]],
     ) -> solana_program::entrypoint::ProgramResult {
         let args = RouteBaseRewardsInstructionArgs {
+            max_iterations: self
+                .instruction
+                .max_iterations
+                .clone()
+                .expect("max_iterations is not set"),
             epoch: self.instruction.epoch.clone().expect("epoch is not set"),
         };
         let instruction = RouteBaseRewardsCpi {
@@ -563,6 +585,7 @@ struct RouteBaseRewardsCpiBuilderInstruction<'a, 'b> {
     base_reward_router: Option<&'b solana_program::account_info::AccountInfo<'a>>,
     base_reward_receiver: Option<&'b solana_program::account_info::AccountInfo<'a>>,
     restaking_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
+    max_iterations: Option<u16>,
     epoch: Option<u64>,
     /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
     __remaining_accounts: Vec<(