Merge pull request #14 from sunrise-stake/feature/yield-router-program-documentation

Add documentation to yield-router program

Author: dankelleher

programs/yield-router/src/lib.rs

@@ -16,6 +16,7 @@ pub mod yield_router {
         sunrise_state: Pubkey,
         state_in: GenericStateInput,
     ) -> Result<()> {
+        // register state account on chain, only need to ever be done once
         let state = &mut ctx.accounts.state;
         state.sunrise_state = sunrise_state;
         state.update_authority = state_in.update_authority;
@@ -24,6 +25,7 @@ pub mod yield_router {
         state.spend_proportions = state_in.spend_proportions;
         state.input_yield_account_bump = *ctx.bumps.get("input_yield_account").unwrap();
 
+        // make sure the input proportions sum up to 100
         check_proportions(&state.spend_proportions)?;
 
         state.total_spent = 0;
@@ -32,12 +34,14 @@ pub mod yield_router {
     }
 
     pub fn update_state(ctx: Context<UpdateState>, state_in: GenericStateInput) -> Result<()> {
+        // update state account parameters
         let state = &mut ctx.accounts.state;
         state.update_authority = state_in.update_authority;
         state.output_yield_accounts = state_in.output_yield_accounts;
         state.spend_threshold = state_in.spend_threshold;
         state.spend_proportions = state_in.spend_proportions;
 
+        // make sure the new proportions sum up to 100
         check_proportions(&state.spend_proportions)?;
 
         Ok(())
@@ -47,15 +51,18 @@ pub mod yield_router {
         ctx: Context<'_, '_, '_, 'info, AllocateYield<'info>>,
         amount: u64,
     ) -> Result<()> {
+        // send yield to output_yield_accounts with specified proportions
         let state = &mut ctx.accounts.state;
         let input_yield_account = &mut ctx.accounts.input_yield_account;
 
         // check output yield accounts
+        // Question: why do we need in additional input `remaining_accounts`?
+        // Why not just loop through the `output_yield_accounts`?
         if ctx.remaining_accounts.len() != state.output_yield_accounts.len() {
             return Err(ErrorCode::IncorrectOutputYieldAccount.into());
         }
 
-        // send to each output yield account
+        // loop through all output yield accounts
         for i in 0..ctx.remaining_accounts.len() {
             let output_yield_account = &ctx.remaining_accounts[i];
             let proportion = state.spend_proportions[i];
@@ -64,8 +71,10 @@ pub mod yield_router {
                 return Err(ErrorCode::IncorrectOutputYieldAccount.into());
             }
 
+            // compute the amount to be send to this output_yield_account based on the specifed proportion
             let amount_to_send = (amount as f64 * (proportion as f64 / 100.0)) as u64;
 
+            // send appropriate fund to this output_yield_account
             transfer_native_cpi(
                 &state.key(),
                 &input_yield_account.to_account_info(),

programs/yield-router/src/utils/spend.rs

@@ -4,7 +4,7 @@ use anchor_lang::prelude::*;
 use anchor_lang::system_program;
 
 pub fn check_proportions(spend_proportions: &[u8]) -> Result<()> {
-    // check proportions sum to 100
+    // check proportions to be spend on different output yield accounts sum to 100
     let mut sum = 0;
     for proportion in spend_proportions.iter() {
         sum += proportion;
@@ -23,9 +23,11 @@ pub fn transfer_native_cpi<'a>(
     source_bump: u8,
     system_program: &Program<'a, System>,
 ) -> Result<()> {
+    // transfer `amount` (in lamports) from `source` account to `dest` account
     let state_bytes = state.to_bytes();
     let bump_bytes = &[source_bump];
     let seeds = &[INPUT_YIELD_ACCOUNT, &state_bytes[..], bump_bytes][..];
+    // Question: how many signers are here? why are they signing?
     let signer_seeds = &[seeds];
     let cpi_ctx = CpiContext::new(
         system_program.to_account_info(),

programs/yield-router/src/utils/state.rs

@@ -5,14 +5,19 @@ use anchor_lang::prelude::*;
 /* This struct will be used for both registering and updating the state account */
 #[derive(AnchorSerialize, AnchorDeserialize, Clone)]
 pub struct GenericStateInput {
+    // an account that can update the `output_yield_accounts` and `spend_proportions`
     pub update_authority: Pubkey,
+    // a vector of accounts to which we will send yields to
     pub output_yield_accounts: Vec<Pubkey>,
-    pub spend_proportions: Vec<u8>, // sum to 100
+    // proportions of sum to send to each of the accounts in `output_yield_accounts` (sum to 100)
+    pub spend_proportions: Vec<u8>,
+    // minimum threshold of yield in input_yield_account before it is allowed to send funds
     pub spend_threshold: u64,
 }
 
 #[account]
 pub struct State {
+    // the state account holding all the configs from GenericStateInput and the info of total yields spent
     pub sunrise_state: Pubkey,
     pub update_authority: Pubkey,
     pub output_yield_accounts: Vec<Pubkey>,
@@ -24,6 +29,7 @@ pub struct State {
 
 impl State {
     pub fn space(output_yield_account_count: u8) -> usize {
+        // find space needed for state account for current config
         32 + 32
             + (32 * output_yield_account_count as usize)
             + 4
@@ -39,6 +45,7 @@ impl State {
 #[derive(Accounts)]
 #[instruction(sunrise_state: Pubkey, state_in: GenericStateInput)]
 pub struct RegisterState<'info> {
+    // to be used for registering state account on chain, only need to ever be done once
     #[account(mut)]
     pub payer: Signer<'info>,
     #[account(
@@ -61,11 +68,13 @@ pub struct RegisterState<'info> {
 #[derive(Accounts)]
 #[instruction(state_in: GenericStateInput)]
 pub struct UpdateState<'info> {
+    // to be used for updating parameters of state account
     #[account(mut)]
     pub payer: Signer<'info>,
     #[account(
     mut,
     constraint = state.update_authority == payer.key() @ ErrorCode::Unauthorized,
+    // resize the state account if necessary
     realloc = State::space(state_in.output_yield_accounts.len() as u8),
     realloc::payer = payer,
     realloc::zero = false,
@@ -77,6 +86,7 @@ pub struct UpdateState<'info> {
 #[derive(Accounts)]
 #[instruction(amount: u64)]
 pub struct AllocateYield<'info> {
+    // to allocate correct yield proportion to various output_yield_accounts
     #[account(mut)]
     pub payer: Signer<'info>,
     pub state: Account<'info, State>,