Testing/Docs for Add ix (#3)

* Document  defi ix, add helper method for tests for setting up accounts for deposits

* Create README.md

* decimal: now using uint crate under the hood

* Document  defi ix, add helper method for tests for setting up accounts for deposits

* Add rustfmt.toml, run rustfmt on all existing files

* Comment out broken part for now

* reverted merge conflict resolution back to original decimal.rs from master

Co-authored-by: z0ji <zoji@maelstrom.finance>

Author: swimricky

README.md

@@ -1 +1,10 @@
 # pool
+
+## Developer Notes
+- don't use `msg!()` in test-bpf tests. use `println!` and  `cargo test-bpf -- --show-output` 
+- run `cargo fmt` to use `rustfmt`
+  - configurations are in `rustfmt.toml`
+### Running Tests
+```bash
+$ cd swim/pool
+$ cargo test-bpf -- --show-output

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

src/amp_factor.rs

@@ -1,10 +1,6 @@
-use borsh::{BorshDeserialize, BorshSerialize, BorshSchema};
+use crate::{decimal::DecimalError, decimal::DecimalU64, error::PoolError};
+use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
 use solana_program::clock::UnixTimestamp;
-use crate::{
-    error::PoolError,
-    decimal::DecimalU64,
-    decimal::DecimalError,
-};
 
 pub type TimestampT = UnixTimestamp;
 pub type ValueT = DecimalU64;
@@ -71,7 +67,7 @@ impl AmpFactor {
             // a 10x over a day (not +10, but potentially much more))
 
             let value_diff = self.target_value - self.initial_value;
-            let time_since_initial = DecimalU64::new((current_ts - self.initial_ts) as u64,0).unwrap();
+            let time_since_initial = DecimalU64::new((current_ts - self.initial_ts) as u64, 0).unwrap();
             let total_adjustment_time = DecimalU64::new((self.target_ts - self.initial_ts) as u64, 0).unwrap();
             let delta = value_diff * (time_since_initial / total_adjustment_time);
 
@@ -94,10 +90,8 @@ impl AmpFactor {
         }
 
         let initial_value = self.get(current_ts);
-        if (initial_value < target_value
-            && initial_value * MAX_RELATIVE_ADJUSTMENT.unwrap() < target_value)
-            || (initial_value > target_value
-                && initial_value > target_value * MAX_RELATIVE_ADJUSTMENT.unwrap())
+        if (initial_value < target_value && initial_value * MAX_RELATIVE_ADJUSTMENT.unwrap() < target_value)
+            || (initial_value > target_value && initial_value > target_value * MAX_RELATIVE_ADJUSTMENT.unwrap())
         {
             return Err(PoolError::InvalidAmpFactorValue);
         }
@@ -134,31 +128,31 @@ mod tests {
 
     #[test]
     fn valid_set_target() {
-        let mut amp = AmpFactor::new(new_u64(10000,0)).unwrap();
+        let mut amp = AmpFactor::new(new_u64(10000, 0)).unwrap();
         assert_eq!(amp.get(1), 10000);
-        
+
         amp.set_target(20000, new_u64(20000, 0), 106400).unwrap();
-        
+
         assert_eq!(amp.get(20000), 10000);
-        assert_eq!(amp.get(30000), new_u64(11157407407407407407,15));
-        assert_eq!(amp.get(50000), new_u64(13472222222222222222,15));
-        assert_eq!(amp.get(70000), new_u64(15787037037037037037,15));
-        assert_eq!(amp.get(90000), new_u64(18101851851851851851,15));
+        assert_eq!(amp.get(30000), new_u64(11157407407407407407, 15));
+        assert_eq!(amp.get(50000), new_u64(13472222222222222222, 15));
+        assert_eq!(amp.get(70000), new_u64(15787037037037037037, 15));
+        assert_eq!(amp.get(90000), new_u64(18101851851851851851, 15));
         assert_eq!(amp.get(106400), 20000);
     }
 
     #[test]
     #[should_panic]
     fn invalid_set_target() {
         //Target value set to 20x initial value
-        let mut amp = AmpFactor::new(new_u64(1000,0)).unwrap();
-        amp.set_target(20000, new_u64(20000,0), 106400).unwrap();
+        let mut amp = AmpFactor::new(new_u64(1000, 0)).unwrap();
+        amp.set_target(20000, new_u64(20000, 0), 106400).unwrap();
     }
 
     #[test]
     #[should_panic]
     fn invalid_adjustment_window() {
-        let mut amp = AmpFactor::new(new_u64(10000,0)).unwrap();
-        amp.set_target(20000, new_u64(20000,0), 50000).unwrap();
+        let mut amp = AmpFactor::new(new_u64(10000, 0)).unwrap();
+        amp.set_target(20000, new_u64(20000, 0), 50000).unwrap();
     }
 }

src/entrypoint.rs

@@ -1,7 +1,5 @@
 use crate::{error::to_error_msg, processor::Processor};
-use solana_program::{
-    account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey,
-};
+use solana_program::{account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, msg, pubkey::Pubkey};
 
 pub const TOKEN_COUNT: usize = 4; //TODO find a proper way to set/configure this
 

src/error.rs

@@ -61,9 +61,7 @@ impl From<PoolError> for ProgramError {
 
 pub fn to_error_msg(error: &ProgramError) -> String {
     match error {
-        ProgramError::Custom(ec) if *ec < OFFSET as u32 => {
-            TokenError::from_u32(*ec).unwrap().to_string()
-        }
+        ProgramError::Custom(ec) if *ec < OFFSET as u32 => TokenError::from_u32(*ec).unwrap().to_string(),
         ProgramError::Custom(ec) => PoolError::from_u32(*ec).unwrap().to_string(),
         e => e.to_string(),
     }

src/instruction.rs

@@ -1,30 +1,35 @@
-use borsh::{BorshDeserialize, BorshSerialize};
-use solana_program::{clock::UnixTimestamp, instruction::{AccountMeta, Instruction}, program_error::ProgramError, pubkey::Pubkey};
 use crate::decimal::DecimalU64;
+use borsh::{BorshDeserialize, BorshSerialize};
+use solana_program::{
+    clock::UnixTimestamp,
+    instruction::{AccountMeta, Instruction},
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
 
 type AmountT = u64;
 type DecT = DecimalU64;
 
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
 pub enum PoolInstruction<const TOKEN_COUNT: usize> {
-    /// Initializes a new pool 
+    /// Initializes a new pool
     ///
     /// Accounts expected by this instruction:
     ///     0. `[w]` The pool state account to initalize
-    ///     1. `[]` LP Token Mint. Must be empty, owned by authority 
+    ///     1. `[]` LP Token Mint. Must be empty, owned by authority
     ///             authority isn't passed in but programatically derived
     ///     2. ..2 + TOKEN_COUNT  `[]` Token mint accounts
     ///     3. ..2 + (2 * TOKEN_COUNT) `[]` Token accounts. Must be empty
     ///     4. ..3 + (2 * TOKEN_COUNT) `[]` Governance account
-    ///     5. ..4 + (2 * TOKEN_COUNT) `[]` Governance Fee account. 
+    ///     5. ..4 + (2 * TOKEN_COUNT) `[]` Governance Fee account.
     Init {
         nonce: u8,
         amp_factor: DecT,
         lp_fee: DecT,
         governance_fee: DecT,
     },
-    DeFiInstruction(DeFiInstruction::<TOKEN_COUNT>),
-    GovernanceInstruction(GovernanceInstruction::<TOKEN_COUNT>)
+    DeFiInstruction(DeFiInstruction<TOKEN_COUNT>),
+    GovernanceInstruction(GovernanceInstruction<TOKEN_COUNT>),
 }
 
 /// Creates an `Init` instruction
@@ -46,37 +51,43 @@ pub fn create_init_ix<const TOKEN_COUNT: usize>(
         AccountMeta::new_readonly(*lp_mint, false),
     ];
     for i in 0..TOKEN_COUNT {
-        accounts.push(
-            AccountMeta::new_readonly(token_mints[i], false)
-        );
-    };
+        accounts.push(AccountMeta::new_readonly(token_mints[i], false));
+    }
     for i in 0..TOKEN_COUNT {
-        accounts.push(
-            AccountMeta::new_readonly(token_accounts[i], false)
-        );
-    };
-    accounts.push(
-        AccountMeta::new_readonly(*governance_account, false)
-    );
-    accounts.push(
-        AccountMeta::new_readonly(*governance_fee_account, false)
-    );
+        accounts.push(AccountMeta::new_readonly(token_accounts[i], false));
+    }
+    accounts.push(AccountMeta::new_readonly(*governance_account, false));
+    accounts.push(AccountMeta::new_readonly(*governance_fee_account, false));
     let data = PoolInstruction::<TOKEN_COUNT>::Init {
         nonce,
         amp_factor,
         lp_fee,
-        governance_fee
-    }.try_to_vec()?;
+        governance_fee,
+    }
+    .try_to_vec()?;
 
     Ok(Instruction {
         program_id: *program_id,
         accounts,
-        data
+        data,
     })
 }
 
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
 pub enum DeFiInstruction<const TOKEN_COUNT: usize> {
+    /// Adds/Deposits the specified input_amounts and mints
+    /// at least `minimum_mint_amount` LP tokens
+    ///
+    /// Accounts expected by this instruction:
+    ///     0. `[w]` The pool state account
+    ///     1. `[]` pool authority
+    ///     2. ..2 + TOKEN_COUNT `[]` pool's token accounts
+    ///     3. ..3 + TOKEN_COUNT `[w]` LP Token Mint
+    ///     4. ..4 + TOKEN_COUNT `[]` governance_fee_account
+    ///     5. ..5 + TOKEN_COUNT `[s]` user transfer authority account
+    ///     6. ..6 + TOKEN_COUNT `[w]` user token accounts
+    ///     7. ..6 + (2 * TOKEN_COUNT) `[]` SPL token program account
+    ///     8. ..7 + (2 * TOKEN_COUNT) `[w]` user LP token account   
     Add {
         input_amounts: [AmountT; TOKEN_COUNT],
         minimum_mint_amount: AmountT,
@@ -103,7 +114,60 @@ pub enum DeFiInstruction<const TOKEN_COUNT: usize> {
     RemoveExactOutput {
         maximum_burn_amount: AmountT,
         exact_output_amounts: [AmountT; TOKEN_COUNT],
+    },
+}
+
+/// Creates an `Add` DefiInstruction
+pub fn create_add_ix<const TOKEN_COUNT: usize>(
+    program_id: &Pubkey,
+    pool: &Pubkey,
+    authority: &Pubkey,
+    pool_token_accounts: [Pubkey; TOKEN_COUNT],
+    lp_mint: &Pubkey,
+    governance_fee_account: &Pubkey,
+    user_transfer_authority: &Pubkey,
+    user_token_accounts: [Pubkey; TOKEN_COUNT],
+    token_program_account: &Pubkey,
+    user_lp_token_account: &Pubkey,
+    input_amounts: [AmountT; TOKEN_COUNT],
+    minimum_mint_amount: AmountT,
+) -> Result<Instruction, ProgramError> {
+    let mut accounts = vec![
+        AccountMeta::new_readonly(*pool, false),
+        AccountMeta::new_readonly(*authority, false),
+    ];
+    for i in 0..TOKEN_COUNT {
+        accounts.push(AccountMeta::new(pool_token_accounts[i], false));
+    }
+    accounts.push(AccountMeta::new(*lp_mint, false));
+    accounts.push(AccountMeta::new(*governance_fee_account, false));
+
+    // used from SPL binary-oracle-pair
+    accounts.push(AccountMeta::new_readonly(
+        *user_transfer_authority,
+        authority != user_transfer_authority,
+    ));
+    for i in 0..TOKEN_COUNT {
+        accounts.push(AccountMeta::new(user_token_accounts[i], false));
     }
+    accounts.push(AccountMeta::new_readonly(*token_program_account, false));
+    accounts.push(AccountMeta::new(*user_lp_token_account, false));
+
+    let d = DeFiInstruction::<TOKEN_COUNT>::Add {
+        input_amounts,
+        minimum_mint_amount,
+    };
+    let data = PoolInstruction::<TOKEN_COUNT>::DeFiInstruction(d).try_to_vec()?;
+    // let data = PoolInstruction::<TOKEN_COUNT>::DeFiInstruction::DeFiInstruction::<TOKEN_COUNT>::Add {
+    //     input_amounts,
+    //     minimum_mint_amount,
+    // }.try_to_vec()?;
+
+    Ok(Instruction {
+        program_id: *program_id,
+        accounts,
+        data,
+    })
 }
 
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
@@ -126,5 +190,5 @@ pub enum GovernanceInstruction<const TOKEN_COUNT: usize> {
     },
     SetPaused {
         paused: bool,
-    }
-}
+    },
+}