refactor: reduce type conversions in earn

Author: Oighty

programs/earn/src/instructions/admin/initialize.rs

@@ -20,7 +20,7 @@ use crate::{
     constants::{ANCHOR_DISCRIMINATOR_SIZE, PORTAL_PROGRAM},
     errors::EarnError,
     state::{EarnGlobal, GLOBAL_SEED, TOKEN_AUTHORITY_SEED},
-    utils::{conversion::update_multiplier, token::thaw_token_account},
+    utils::{conversion::{update_multiplier, index_to_multiplier}, token::thaw_token_account},
 };
 
 cfg_if::cfg_if!(
@@ -177,20 +177,20 @@ impl Initialize<'_> {
 
                 // Set the multiplier on the m_mint to the current index and timestamp on the old earn program
                 update_multiplier(
-                    &mut ctx.accounts.m_mint,                         // mint
-                    &ctx.accounts.global_account.to_account_info(),   // authority
-                    &[&[GLOBAL_SEED, &[ctx.bumps.global_account]]],   // authority seeds
-                    &ctx.accounts.token_program,                      // token program
-                    ctx.accounts.old_global_account.index,            // index
-                    ctx.accounts.old_global_account.timestamp as i64, // timestamp
+                    &mut ctx.accounts.m_mint,                                       // mint
+                    &ctx.accounts.global_account.to_account_info(),                 // authority
+                    &[&[GLOBAL_SEED, &[ctx.bumps.global_account]]],                 // authority seeds
+                    &ctx.accounts.token_program,                                    // token program
+                    index_to_multiplier(ctx.accounts.old_global_account.index)?,    // index
+                    ctx.accounts.old_global_account.timestamp as i64,               // timestamp
                 )?;
             } else {
                 update_multiplier(
                     &mut ctx.accounts.m_mint,                       // mint
                     &ctx.accounts.global_account.to_account_info(), // authority
                     &[&[GLOBAL_SEED, &[ctx.bumps.global_account]]], // authority seeds
                     &ctx.accounts.token_program,                    // token program
-                    _current_index,                                 // index
+                    index_to_multiplier(_current_index)?,            // index
                     Clock::get()?.unix_timestamp,                   // timestamp
                 )?;
             }

programs/earn/src/instructions/portal/propagate_index.rs

@@ -4,10 +4,9 @@ use anchor_spl::token_interface::{Mint, Token2022};
 
 // local dependencies
 use crate::{
-    constants::INDEX_SCALE_F64,
     errors::EarnError,
     state::{EarnGlobal, GLOBAL_SEED},
-    utils::conversion::{get_scaled_ui_config, update_multiplier},
+    utils::conversion::{get_scaled_ui_config, update_multiplier, index_to_multiplier},
 };
 
 #[derive(Accounts)]
@@ -40,10 +39,10 @@ impl PropagateIndex<'_> {
     ) -> Result<()> {
         let scaled_ui_config = get_scaled_ui_config(&ctx.accounts.m_mint)?;
         let current_multiplier: f64 = scaled_ui_config.new_multiplier.into();
-        let current_index = (INDEX_SCALE_F64 * current_multiplier).trunc() as u64;
+        let new_multiplier = index_to_multiplier(new_index)?;
 
-        // Check if the new index is greater than or equal to the previously seen index.
-        if new_index >= current_index {
+        // Check if the new multiplier is greater than or equal to the previously seen multiplier.
+        if new_multiplier >= current_multiplier {
             // If so, update the merkle root if it is non-zero.
             // We don't necessarily need the second check if we know updates only come
             // from mainnet. However, it provides some protection against staleness
@@ -52,16 +51,16 @@ impl PropagateIndex<'_> {
                 ctx.accounts.global_account.earner_merkle_root = earner_merkle_root;
             }
 
-            // If the new index is strictly greater than the current one, update the multiplier.
-            if new_index > current_index {
+            // If the new multiplier is strictly greater than the current one, update the multiplier.
+            if new_multiplier > current_multiplier {
                 let timestamp = Clock::get()?.unix_timestamp;
 
                 update_multiplier(
                     &mut ctx.accounts.m_mint,
                     &ctx.accounts.global_account.to_account_info(),
                     &[&[GLOBAL_SEED, &[ctx.accounts.global_account.bump]]],
                     &ctx.accounts.token_program,
-                    new_index,
+                    new_multiplier,
                     timestamp,
                 )?;
 

programs/earn/src/utils/conversion.rs

@@ -14,11 +14,9 @@ pub fn update_multiplier<'info>(
     authority: &AccountInfo<'info>,
     authority_seeds: &[&[&[u8]]],
     token_program: &Program<'info, Token2022>,
-    index: u64,
+    multiplier: f64,
     timestamp: i64,
 ) -> Result<()> {
-    let multiplier = (index as f64) / INDEX_SCALE_F64;
-
     // Only update multiplier if the new multiplier is greater than the current multiplier
     // Indices in the M protocol are monotonically increasing, but we may receive a stale update
     // from another chain.
@@ -137,6 +135,23 @@ pub fn principal_to_amount_up(principal: u64, multiplier: f64) -> Result<u64> {
     Ok(amount)
 }
 
+pub fn multiplier_to_index(multiplier: f64) -> Result<u64> {
+    let index: f64 = (INDEX_SCALE_F64 * multiplier).trunc();
+
+    if index < 0.0 {
+        err!(EarnError::MathUnderflow)
+    } else if index > u64::MAX as f64 {
+        err!(EarnError::MathOverflow)
+    } else {
+        // Convert the f64 index to u64
+        Ok(index as u64)
+    }
+}
+
+pub fn index_to_multiplier(index: u64) -> Result<f64> {
+    Ok(index as f64 / INDEX_SCALE_F64)
+}
+
 pub fn get_mint_extensions<'info>(
     mint: &InterfaceAccount<'info, Mint>,
 ) -> Result<Vec<spl_token_2022::extension::ExtensionType>> {