Refactor program misc

controller/program/src/instructions/admin/add_lst.rs

@@ -1,14 +1,13 @@
 use crate::{
-    utils::extend_lst_state_list,
+    utils::{accs_split_first_chunk, extend_lst_state_list},
     verify::{
-        verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers,
-        verify_sol_value_calculator_is_program, verify_tokenkeg_or_22_mint,
+        verify_lst_state_list_no_dup, verify_not_rebalancing_and_not_disabled, verify_pks,
+        verify_signers, verify_sol_value_calculator_is_program, verify_tokenkeg_or_22_mint,
     },
     Cpi,
 };
 use inf1_ctl_jiminy::{
-    account_utils::{lst_state_list_checked_mut, pool_state_v2_checked},
-    accounts::lst_state_list::LstStatePackedList,
+    account_utils::{lst_state_list_checked, lst_state_list_checked_mut, pool_state_v2_checked},
     err::Inf1CtlErr,
     instructions::admin::add_lst::{AddLstIxAccs, NewAddLstIxAccsBuilder, ADD_LST_IX_IS_SIGNER},
     keys::{ATOKEN_ID, LST_STATE_LIST_ID, POOL_STATE_ID, PROTOCOL_FEE_ID, SYS_PROG_ID},
@@ -18,9 +17,9 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, INVALID_SEEDS, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::{ProgramError, INVALID_SEEDS},
 };
-use jiminy_sysvar_rent::{sysvar::SimpleSysvar, Rent};
+use jiminy_sysvar_rent::Rent;
 use sanctum_ata_jiminy::sanctum_ata_core::instructions::create::{
     CreateIdempotentIxData, NewCreateIxAccsBuilder,
 };
@@ -29,10 +28,11 @@ use sanctum_system_jiminy::sanctum_system_core::instructions::transfer::NewTrans
 #[inline]
 pub fn process_add_lst(
     abr: &mut Abr,
-    accounts: &[AccountHandle],
     cpi: &mut Cpi,
+    accs: &[AccountHandle],
+    rent: &Rent,
 ) -> Result<(), ProgramError> {
-    let accs = accounts.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = AddLstIxAccs(*accs);
 
     let pool = pool_state_v2_checked(abr.get(*accs.pool_state()))?;
@@ -72,17 +72,13 @@ pub fn process_add_lst(
     verify_tokenkeg_or_22_mint(lst_mint_acc)?;
     verify_sol_value_calculator_is_program(abr.get(*accs.sol_value_calculator()))?;
 
-    // Verify no duplicate in lst state list
-    let lst_state_list_acc = abr.get(*accs.lst_state_list());
-    let list = LstStatePackedList::of_acc_data(lst_state_list_acc.data())
-        .ok_or(Inf1CtlCustomProgErr(Inf1CtlErr::InvalidLstStateListData))?;
-
-    if list.find_by_mint(lst_mint_acc.key()).is_some() {
-        return Err(Inf1CtlCustomProgErr(Inf1CtlErr::DuplicateLst).into());
-    }
+    let list = lst_state_list_checked(abr.get(*accs.lst_state_list()))?.0;
+    verify_lst_state_list_no_dup(list, lst_mint_acc.key())?;
 
     // idx=u32::MAX is reserved for LP mint
-    if list.0.len() >= u32::MAX as usize {
+    // cant even test this because at this number, the size of list
+    // exceeds max account size of 10MB lul
+    if list.len() >= u32::MAX as usize {
         return Err(Inf1CtlCustomProgErr(Inf1CtlErr::IndexTooLarge).into());
     }
 
@@ -124,7 +120,7 @@ pub fn process_add_lst(
             .with_from(*accs.payer())
             .with_to(*accs.lst_state_list())
             .build(),
-        &Rent::get()?,
+        rent,
     )?;
 
     // Add lst state to lst state list

controller/program/src/instructions/admin/lst_input/common.rs

@@ -12,11 +12,11 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
 use crate::{
-    utils::ix_data_as_arr,
+    utils::{accs_split_first_chunk, ix_data_as_arr},
     verify::{verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers},
 };
 
@@ -26,7 +26,7 @@ pub fn set_lst_input_checked<'acc>(
     accs: &[AccountHandle<'acc>],
     data_no_discm: &[u8],
 ) -> Result<(SetLstInputIxAccs<AccountHandle<'acc>>, usize), ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = SetLstInputIxAccs(*accs);
 
     let idx = u32_ix_data_parse_no_discm(ix_data_as_arr(data_no_discm)?) as usize;

controller/program/src/instructions/admin/remove_lst.rs

@@ -13,9 +13,9 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
-use jiminy_sysvar_rent::{sysvar::SimpleSysvar, Rent};
+use jiminy_sysvar_rent::Rent;
 use sanctum_spl_token_jiminy::{
     instructions::close_account::close_account_ix_account_handle_perms,
     sanctum_spl_token_core::instructions::close_account::{
@@ -26,7 +26,7 @@ use sanctum_system_jiminy::sanctum_system_core::instructions::transfer::NewTrans
 
 use crate::{
     token::get_token_account_amount,
-    utils::shrink_lst_state_list,
+    utils::{accs_split_first_chunk, shrink_lst_state_list},
     verify::{verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers},
     Cpi,
 };
@@ -35,10 +35,11 @@ use crate::{
 pub fn process_remove_lst(
     abr: &mut Abr,
     cpi: &mut Cpi,
-    accounts: &[AccountHandle],
+    accs: &[AccountHandle],
     lst_idx: usize,
+    rent: &Rent,
 ) -> Result<(), ProgramError> {
-    let accs = accounts.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = RemoveLstIxAccs(*accs);
 
     let list = lst_state_list_checked(abr.get(*accs.lst_state_list()))?;
@@ -120,7 +121,7 @@ pub fn process_remove_lst(
             .with_from(*accs.lst_state_list())
             .with_to(*accs.refund_rent_to())
             .build(),
-        &Rent::get()?,
+        rent,
         lst_idx,
     )?;
 

controller/program/src/instructions/admin/set_admin.rs

@@ -7,10 +7,13 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
-use crate::verify::{verify_pks, verify_signers};
+use crate::{
+    utils::accs_split_first_chunk,
+    verify::{verify_pks, verify_signers},
+};
 
 type SetAdminIxAccounts<'acc> = SetAdminIxAccs<AccountHandle<'acc>>;
 
@@ -19,7 +22,7 @@ pub fn set_admin_accs_checked<'acc>(
     abr: &mut Abr,
     accs: &[AccountHandle<'acc>],
 ) -> Result<SetAdminIxAccounts<'acc>, ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = SetAdminIxAccs(*accs);
 
     let pool = pool_state_v2_checked(abr.get(*accs.pool_state()))?;
@@ -38,7 +41,7 @@ pub fn set_admin_accs_checked<'acc>(
 }
 
 #[inline]
-pub fn process_set_admin(abr: &mut Abr, accs: SetAdminIxAccounts) -> Result<(), ProgramError> {
+pub fn process_set_admin(abr: &mut Abr, accs: &SetAdminIxAccounts) -> Result<(), ProgramError> {
     let new_admin = *abr.get(*accs.new()).key();
     let pool = pool_state_v2_checked_mut(abr.get_mut(*accs.pool_state()))?;
     pool.admin = new_admin;

controller/program/src/instructions/admin/set_pricing_prog.rs

@@ -7,12 +7,15 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
-use crate::verify::{
-    verify_not_rebalancing_and_not_disabled, verify_pks, verify_pricing_program_is_program,
-    verify_signers,
+use crate::{
+    utils::accs_split_first_chunk,
+    verify::{
+        verify_not_rebalancing_and_not_disabled, verify_pks, verify_pricing_program_is_program,
+        verify_signers,
+    },
 };
 
 type SetPricingProgIxAccounts<'acc> = SetPricingProgIxAccs<AccountHandle<'acc>>;
@@ -22,7 +25,7 @@ pub fn set_pricing_prog_accs_checked<'acc>(
     abr: &mut Abr,
     accs: &[AccountHandle<'acc>],
 ) -> Result<SetPricingProgIxAccounts<'acc>, ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = SetPricingProgIxAccs(*accs);
 
     let pool = pool_state_v2_checked(abr.get(*accs.pool_state()))?;
@@ -48,7 +51,7 @@ pub fn set_pricing_prog_accs_checked<'acc>(
 #[inline]
 pub fn process_set_pricing_prog(
     abr: &mut Abr,
-    accs: SetPricingProgIxAccounts,
+    accs: &SetPricingProgIxAccounts,
 ) -> Result<(), ProgramError> {
     let new_pp = *abr.get(*accs.new()).key();
     let pool = pool_state_v2_checked_mut(abr.get_mut(*accs.pool_state()))?;

controller/program/src/instructions/admin/set_sol_value_calculator.rs

@@ -18,7 +18,7 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
 use inf1_core::instructions::admin::set_sol_value_calculator::SetSolValueCalculatorIxAccs;
@@ -27,7 +27,7 @@ use jiminy_sysvar_clock::Clock;
 
 use crate::{
     svc::lst_ssv_uy,
-    utils::split_suf_accs,
+    utils::{accs_split_first_chunk, split_suf_accs},
     verify::{
         verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers,
         verify_sol_value_calculator_is_program,
@@ -48,7 +48,7 @@ pub fn set_sol_value_calculator_accs_checked<'a, 'acc>(
     accs: &'a [AccountHandle<'acc>],
     lst_idx: usize,
 ) -> Result<SetSolValueCalculatorIxAccounts<'a, 'acc>, ProgramError> {
-    let (ix_prefix, suf) = accs.split_first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (ix_prefix, suf) = accs_split_first_chunk(accs)?;
     let ix_prefix = SetSolValueCalculatorIxPreAccs(*ix_prefix);
 
     let list = lst_state_list_checked(abr.get(*ix_prefix.lst_state_list()))?;

controller/program/src/instructions/disable_pool/add_disable_pool_auth.rs

@@ -12,14 +12,14 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
     Cpi,
 };
-use jiminy_sysvar_rent::{sysvar::SimpleSysvar, Rent};
+use jiminy_sysvar_rent::Rent;
 use sanctum_system_jiminy::sanctum_system_core::instructions::transfer::NewTransferIxAccsBuilder;
 
 use crate::{
-    utils::extend_disable_pool_auth_list,
+    utils::{accs_split_first_chunk, extend_disable_pool_auth_list},
     verify::{verify_disable_pool_auth_list_no_dup, verify_pks, verify_signers},
 };
 
@@ -30,7 +30,7 @@ pub fn add_disable_pool_auth_accs_checked<'acc>(
     abr: &Abr,
     accs: &[AccountHandle<'acc>],
 ) -> Result<AddDisablePoolAuthAccounts<'acc>, ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = AddDisablePoolAuthIxAccs(*accs);
 
     let pool = pool_state_v2_checked(abr.get(*accs.pool_state()))?;
@@ -61,6 +61,7 @@ pub fn process_add_disable_pool_auth(
     abr: &mut Abr,
     cpi: &mut Cpi,
     accs: &AddDisablePoolAuthAccounts,
+    rent: &Rent,
 ) -> Result<(), ProgramError> {
     extend_disable_pool_auth_list(
         abr,
@@ -69,7 +70,7 @@ pub fn process_add_disable_pool_auth(
             .with_from(*accs.payer())
             .with_to(*accs.disable_pool_auth_list())
             .build(),
-        &Rent::get()?,
+        rent,
     )?;
     let new_auth = *abr.get(*accs.new()).key();
     let list = disable_pool_auth_list_checked_mut(abr.get_mut(*accs.disable_pool_auth_list()))?;

controller/program/src/instructions/disable_pool/disable.rs

@@ -13,10 +13,13 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
-use crate::verify::{verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers};
+use crate::{
+    utils::accs_split_first_chunk,
+    verify::{verify_not_rebalancing_and_not_disabled, verify_pks, verify_signers},
+};
 
 type DisablePoolIxAccounts<'acc> = DisablePoolIxAccs<AccountHandle<'acc>>;
 
@@ -25,7 +28,7 @@ pub fn disable_pool_accs_checked<'acc>(
     abr: &mut Abr,
     accs: &[AccountHandle<'acc>],
 ) -> Result<DisablePoolIxAccounts<'acc>, ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = DisablePoolIxAccs(*accs);
 
     let signer_pk = abr.get(*accs.signer()).key();

controller/program/src/instructions/disable_pool/enable.rs

@@ -11,10 +11,13 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::ProgramError,
 };
 
-use crate::verify::{verify_pks, verify_signers};
+use crate::{
+    utils::accs_split_first_chunk,
+    verify::{verify_pks, verify_signers},
+};
 
 type EnablePoolIxAccounts<'acc> = EnablePoolIxAccs<AccountHandle<'acc>>;
 
@@ -23,7 +26,7 @@ pub fn enable_pool_accs_checked<'acc>(
     abr: &Abr,
     accs: &[AccountHandle<'acc>],
 ) -> Result<EnablePoolIxAccounts<'acc>, ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = EnablePoolIxAccs(*accs);
 
     let PoolStateV2 {

controller/program/src/instructions/disable_pool/remove_disable_pool_auth.rs

@@ -13,13 +13,13 @@ use inf1_ctl_jiminy::{
 };
 use jiminy_cpi::{
     account::{Abr, AccountHandle},
-    program_error::{ProgramError, INVALID_INSTRUCTION_DATA, NOT_ENOUGH_ACCOUNT_KEYS},
+    program_error::{ProgramError, INVALID_INSTRUCTION_DATA},
 };
-use jiminy_sysvar_rent::{sysvar::SimpleSysvar, Rent};
+use jiminy_sysvar_rent::Rent;
 use sanctum_system_jiminy::sanctum_system_core::instructions::transfer::NewTransferIxAccsBuilder;
 
 use crate::{
-    utils::shrink_disable_pool_auth_list,
+    utils::{accs_split_first_chunk, shrink_disable_pool_auth_list},
     verify::{verify_pks, verify_signers},
 };
 
@@ -31,7 +31,7 @@ pub fn remove_disable_pool_auth_checked<'acc>(
     accs: &[AccountHandle<'acc>],
     data_no_discm: &[u8],
 ) -> Result<(RemoveDisablePoolAuthAccounts<'acc>, usize), ProgramError> {
-    let accs = accs.first_chunk().ok_or(NOT_ENOUGH_ACCOUNT_KEYS)?;
+    let (accs, _) = accs_split_first_chunk(accs)?;
     let accs = RemoveDisablePoolAuthIxAccs(*accs);
 
     let idx = RemoveDisablePoolAuthIxData::parse_no_discm(
@@ -72,14 +72,15 @@ pub fn process_remove_disable_pool_auth(
     abr: &mut Abr,
     accs: &RemoveDisablePoolAuthAccounts,
     idx: usize,
+    rent: &Rent,
 ) -> Result<(), ProgramError> {
     shrink_disable_pool_auth_list(
         abr,
         &NewTransferIxAccsBuilder::start()
             .with_from(*accs.disable_pool_auth_list())
             .with_to(*accs.refund_rent_to())
             .build(),
-        &Rent::get()?,
+        rent,
         idx,
     )
 }