fix: lints

Author: carrion256

contract/vault/src/aux.rs

@@ -33,7 +33,7 @@ pub enum ReturnStyle {
 
 // TODO: use this
 impl ReturnStyle {
-    pub fn serialize(
+    #[must_use] pub fn serialize(
         &self,
         amount: templar_common::asset::FungibleAssetAmount<impl templar_common::asset::AssetClass>,
     ) -> serde_json::Value {

contract/vault/src/impl_callbacks.rs

@@ -3,7 +3,7 @@ use std::fmt::Display;
 use crate::{ext_self, near, Contract, ContractExt, Error, Nep141Controller, OpState};
 use near_contract_standards::fungible_token::core::ext_ft_core;
 use near_sdk::{
-    env, json_types::U128, serde_json, AccountId, Gas, NearToken, Promise, PromiseError,
+    env, json_types::U128, AccountId, NearToken, PromiseError,
     PromiseOrValue,
 };
 use near_sdk_contract_tools::ft::nep141::GAS_FOR_FT_TRANSFER_CALL;
@@ -30,7 +30,7 @@ impl Contract {
         attempted: U128,
     ) -> PromiseOrValue<()> {
         // Invariant: Index drift or stale op_id results in a graceful stop
-        let _ = if let Err(e) = self.ctx_allocating(op_id) {
+        let () = if let Err(e) = self.ctx_allocating(op_id) {
             return self.stop_and_exit(Some(&e));
         };
 
@@ -503,7 +503,7 @@ impl Contract {
                 index,
                 remaining: U128(remaining),
                 collected: U128(collected),
-                reason: msg.map(|m| m.to_string()),
+                reason: msg.map(std::string::ToString::to_string),
             }
             .emit();
         }
@@ -540,7 +540,7 @@ impl Contract {
                     op_id: *op_id,
                     receiver: receiver.clone(),
                     amount: U128(*amount),
-                    reason: msg.map(|m| m.to_string()),
+                    reason: msg.map(std::string::ToString::to_string),
                 }
                 .emit();
             }
@@ -670,16 +670,16 @@ mod tests {
     use std::u128;
 
     use crate::test_utils::*;
-    use crate::Contract;
+    
     use near_sdk::json_types::U128;
-    use near_sdk::test_utils::{accounts, VMContextBuilder};
-    use near_sdk::{test_utils::testing_env_with_promise_results, AccountId, PromiseOrValue};
-    use near_sdk::{test_vm_config, testing_env, PromiseResult, RuntimeFeesConfig};
+    use near_sdk::test_utils::accounts;
+    use near_sdk::PromiseOrValue;
+    use near_sdk::PromiseResult;
     use rstest::rstest;
-    use templar_common::asset::{BorrowAsset, FungibleAsset};
+    
     use templar_common::vault::Error;
-    use templar_common::vault::{AllocationMode, OpState, VaultConfiguration};
-    use test_utils::vault_configuration;
+    use templar_common::vault::OpState;
+    
 
     #[test]
     fn after_supply_1_check_allocating_not_allocating() {
@@ -834,7 +834,7 @@ mod tests {
             OpState::Payout { amount, .. } => {
                 assert_eq!(*amount, 70, "Payout amount must match collected + credited");
             }
-            other => panic!("Unexpected state after read: {:?}", other),
+            other => panic!("Unexpected state after read: {other:?}"),
         }
     }
 
@@ -952,9 +952,9 @@ mod tests {
 
         match &c.op_state {
             OpState::Payout { amount, .. } => {
-                assert_eq!(*amount, collected, "Payout amount must equal collected")
+                assert_eq!(*amount, collected, "Payout amount must equal collected");
             }
-            other => panic!("Unexpected state: {:?}", other),
+            other => panic!("Unexpected state: {other:?}"),
         }
     }
 
@@ -1009,9 +1009,9 @@ mod tests {
 
         match &c.op_state {
             OpState::Payout { amount, .. } => {
-                assert_eq!(*amount, collected, "Payout amount must equal collected")
+                assert_eq!(*amount, collected, "Payout amount must equal collected");
             }
-            other => panic!("Unexpected state: {:?}", other),
+            other => panic!("Unexpected state: {other:?}"),
         }
     }
 
@@ -1046,24 +1046,18 @@ mod tests {
         let call_idx = if pass_index { real_idx } else { real_idx + 1 };
 
         let r = c.after_exec_withdraw_read(Ok(None), call_op, call_idx, U128(10), U128(1));
-        match (pass_op, pass_index) {
-            (true, true) => {
-                assert!(
-                    !matches!(c.op_state, OpState::Idle),
-                    "Valid callback should not immediately stop"
-                );
-            }
-            _ => {
-                // Any mismatch should stop and go Idle
-                match r {
-                    PromiseOrValue::Value(()) => {}
-                    _ => {}
-                }
-                assert!(
-                    matches!(c.op_state, OpState::Idle),
-                    "Mismatched callback must stop and go Idle"
-                );
-            }
+        if let (true, true) = (pass_op, pass_index) {
+            assert!(
+                !matches!(c.op_state, OpState::Idle),
+                "Valid callback should not immediately stop"
+            );
+        } else {
+            // Any mismatch should stop and go Idle
+            if let PromiseOrValue::Value(()) = r {}
+            assert!(
+                matches!(c.op_state, OpState::Idle),
+                "Mismatched callback must stop and go Idle"
+            );
         }
     }
 

contract/vault/src/lib.rs

@@ -4,7 +4,7 @@ use near_contract_standards::fungible_token::core::ext_ft_core;
 use near_sdk::{
     env,
     json_types::U128,
-    near, require, serde_json,
+    near, serde_json,
     store::{IterableMap, LookupMap, Vector},
     AccountId, BorshStorageKey, IntoStorageKey, PanicOnDefault, Promise, PromiseOrValue,
 };
@@ -146,7 +146,7 @@ impl Contract {
     /// - `fee_recipient`: account to receive performance fees.
     /// - `skim_recipient`: account to receive skimmed tokens.
     /// - `name`/`symbol`/`decimals`: metadata for the share token.
-    pub fn new(configuration: VaultConfiguration) -> Self {
+    #[must_use] pub fn new(configuration: VaultConfiguration) -> Self {
         let VaultConfiguration {
             owner,
             curator,
@@ -1054,9 +1054,9 @@ impl Contract {
         .emit();
     }
 
-    /// Computes fee-aware effective totals for conversions, mimicking MetaMorpho:
+    /// Computes fee-aware effective totals for conversions, mimicking `MetaMorpho`:
     /// - Include fee shares that would be minted if fees accrued now.
-    /// - Apply virtual offsets: +virtual_shares to supply and +virtual_assets to assets.
+    /// - Apply virtual offsets: +`virtual_shares` to supply and +`virtual_assets` to assets.
     fn effective_totals_fee_aware(&self) -> (u128, u128) {
         let cur = self.get_total_assets().0;
         let ts = self.total_supply();

contract/vault/src/storage_management.rs

@@ -1,5 +1,4 @@
 use crate::PendingWithdrawal;
-use near_sdk::borsh::{self, BorshSerialize};
 use near_sdk::{env, AccountId};
 use std::collections::HashSet;
 use templar_common::vault::{storage_bytes_for_account_id, MarketConfiguration};
@@ -12,52 +11,52 @@ use templar_common::vault::{storage_bytes_for_account_id, MarketConfiguration};
 pub const MAP_ENTRY_OVERHEAD: u64 = 64;
 
 pub const VEC_ITEM_OVERHEAD: u64 = 16;
-pub fn storage_bytes_for_queue_account_id() -> u64 {
+#[must_use] pub fn storage_bytes_for_queue_account_id() -> u64 {
     VEC_ITEM_OVERHEAD + storage_bytes_for_account_id()
 }
 
-pub fn storage_bytes_for_config_entry() -> u64 {
+#[must_use] pub fn storage_bytes_for_config_entry() -> u64 {
     let key = storage_bytes_for_account_id();
     MAP_ENTRY_OVERHEAD + key + MarketConfiguration::encoded_size() as u64
 }
 
-pub fn storage_bytes_for_market_supply_entry() -> u64 {
+#[must_use] pub fn storage_bytes_for_market_supply_entry() -> u64 {
     let key = storage_bytes_for_account_id();
     // u128 principal
     let val = 16u64;
     MAP_ENTRY_OVERHEAD + key + val
 }
 
-pub fn storage_bytes_for_pending_cap_entry() -> u64 {
+#[must_use] pub fn storage_bytes_for_pending_cap_entry() -> u64 {
     let key = storage_bytes_for_account_id();
     // PendingValue { value: u128, valid_at: u64 }
     let val = 16u64 + 8u64;
     MAP_ENTRY_OVERHEAD + key + val
 }
 
-pub fn storage_bytes_for_pending_withdrawal() -> u64 {
+#[must_use] pub fn storage_bytes_for_pending_withdrawal() -> u64 {
     // Key is u64 id -> 8 bytes
     let key = 8u64;
     let val = PendingWithdrawal::encoded_size();
     MAP_ENTRY_OVERHEAD + key + val
 }
 
-pub fn yocto_for_bytes(bytes: u64) -> u128 {
+#[must_use] pub fn yocto_for_bytes(bytes: u64) -> u128 {
     let price = env::storage_byte_cost().as_yoctonear();
     u128::from(bytes).saturating_mul(price)
 }
 
-pub fn yocto_for_new_market() -> u128 {
+#[must_use] pub fn yocto_for_new_market() -> u128 {
     yocto_for_bytes(
         storage_bytes_for_config_entry().saturating_add(storage_bytes_for_market_supply_entry()),
     )
 }
 
-pub fn yocto_for_pending_cap() -> u128 {
+#[must_use] pub fn yocto_for_pending_cap() -> u128 {
     yocto_for_bytes(storage_bytes_for_pending_cap_entry())
 }
 
-pub fn yocto_for_queue_additions(current: &HashSet<AccountId>, new: &[AccountId]) -> u128 {
+#[must_use] pub fn yocto_for_queue_additions(current: &HashSet<AccountId>, new: &[AccountId]) -> u128 {
     new.iter().fold(0u128, |acc, id| {
         if current.contains(id) {
             acc
@@ -67,24 +66,21 @@ pub fn yocto_for_queue_additions(current: &HashSet<AccountId>, new: &[AccountId]
     })
 }
 
-pub fn require_attached_at_least(required_yocto: u128, ctx: &str) -> u128 {
+#[must_use] pub fn require_attached_at_least(required_yocto: u128, ctx: &str) -> u128 {
     let attached = env::attached_deposit().as_yoctonear();
     assert!(
         attached >= required_yocto,
-        "Insufficient storage deposit for {}: required {}, attached {}",
-        ctx,
-        required_yocto,
-        attached
+        "Insufficient storage deposit for {ctx}: required {required_yocto}, attached {attached}"
     );
     required_yocto
 }
 
-pub fn require_attached_for_bytes(bytes: u64, ctx: &str) -> u128 {
+#[must_use] pub fn require_attached_for_bytes(bytes: u64, ctx: &str) -> u128 {
     let req = yocto_for_bytes(bytes);
     require_attached_at_least(req, ctx)
 }
 
-pub fn require_attached_for_pending_withdrawal() -> u128 {
+#[must_use] pub fn require_attached_for_pending_withdrawal() -> u128 {
     let bytes = storage_bytes_for_pending_withdrawal();
     require_attached_for_bytes(bytes, "withdrawal request")
 }

contract/vault/src/test_utils.rs

@@ -5,8 +5,6 @@ pub use near_sdk::{
     test_vm_config, testing_env, AccountId, PromiseResult, RuntimeFeesConfig,
 };
 use near_sdk_contract_tools::ft::Nep141Controller as _;
-use rstest::rstest;
-use templar_common::vault::{AllocationMode, OpState, VaultConfiguration};
 use test_utils::vault_configuration;
 
 pub fn mk(n: u32) -> AccountId {

contract/vault/src/tests.rs

@@ -1,21 +1,16 @@
-use crate::storage_management;
-use crate::storage_management::storage_bytes_for_pending_cap_entry;
 use crate::storage_management::storage_bytes_for_queue_account_id;
 use crate::storage_management::yocto_for_bytes;
 use crate::storage_management::yocto_for_new_market;
 use crate::test_utils::*;
 use crate::Contract;
 use near_sdk::env;
 use near_sdk::test_utils::accounts;
-use near_sdk::{json_types::U128, AccountId, RuntimeFeesConfig};
-use near_sdk::{test_vm_config, testing_env};
+use near_sdk::{json_types::U128, AccountId};
 use near_sdk_contract_tools::ft::Nep141Controller as _;
 use near_sdk_contract_tools::owner::OwnerExternal;
 use rstest::rstest;
-use templar_common::asset::{BorrowAsset, FungibleAsset};
 use templar_common::vault::MarketConfiguration;
 use templar_common::vault::OpState;
-use templar_common::vault::{AllocationMode, VaultConfiguration};
 
 #[rstest(len => [2usize, 3, 5])]
 #[should_panic = "Duplicate market"]
@@ -142,8 +137,8 @@ fn execute_next_withdrawal_request_skips_holes() {
     let owner = c.own_get_owner().unwrap();
     setup_env(&vault_id, &owner, vec![]);
 
-    println!("vault_id: {}", vault_id);
-    println!("owner: {}", owner);
+    println!("vault_id: {vault_id}");
+    println!("owner: {owner}");
 
     // Bob gets 20 shares
     c.deposit_unchecked(&owner, 20).unwrap();
@@ -722,7 +717,7 @@ fn clamp_allocation_total_matches_min_bounds_cases(
     c.supply_queue.push(m.clone());
     c.idle_balance = idle;
 
-    let room = if cap > cur { cap - cur } else { 0 };
+    let room = cap.saturating_sub(cur);
     let requested = req.unwrap_or(c.idle_balance);
     let expect = requested.min(c.idle_balance).min(room);
 

contract/vault/src/wad.rs

@@ -6,14 +6,14 @@ pub const WAD: u128 = 1e18 as u128;
 
 /// Multiplies two WAD-scaled values and floors the result: floor(x * y / WAD).
 #[inline]
-pub fn mul_wad_floor(x: u128, y: u128) -> u128 {
+#[must_use] pub fn mul_wad_floor(x: u128, y: u128) -> u128 {
     mul_div_floor(x, y, WAD)
 }
 
 /// Multiplies and divides with flooring: floor(x * y / denom).
 /// Uses 256-bit intermediate to avoid overflow; returns 0 if denom is 0.
 #[inline]
-pub fn mul_div_floor(x: u128, y: u128, denom: u128) -> u128 {
+#[must_use] pub fn mul_div_floor(x: u128, y: u128, denom: u128) -> u128 {
     if denom == 0 {
         return 0;
     }
@@ -25,7 +25,7 @@ pub fn mul_div_floor(x: u128, y: u128, denom: u128) -> u128 {
 /// Multiplies and divides with ceiling: ceil(x * y / denom).
 /// Uses 256-bit intermediate to avoid overflow; returns 0 if denom is 0.
 #[inline]
-pub fn mul_div_ceil(x: u128, y: u128, denom: u128) -> u128 {
+#[must_use] pub fn mul_div_ceil(x: u128, y: u128, denom: u128) -> u128 {
     if denom == 0 {
         return 0;
     }
@@ -43,7 +43,7 @@ pub fn mul_div_ceil(x: u128, y: u128, denom: u128) -> u128 {
 ///
 /// Floors intermediate divisions; returns 0 when no profit, zero fee, or zero supply.
 #[inline]
-pub fn compute_fee_shares(
+#[must_use] pub fn compute_fee_shares(
     cur_total_assets: u128,
     last_total_assets: u128,
     performance_fee: u128,

contract/vault/tests/happy_path.rs

@@ -1,7 +1,7 @@
-use near_sdk::{json_types::U128, AccountId};
+use near_sdk::json_types::U128;
 use templar_common::{interest_rate_strategy::InterestRateStrategy, number::Decimal};
 use test_utils::{
-    controller::vault::UnifiedVaultController, setup_test, ContractController, MarketController,
+    controller::vault::UnifiedVaultController, setup_test, ContractController,
     UnifiedMarketController,
 };
 

contract/vault/tests/invariants.rs

@@ -1,8 +1,5 @@
-use near_sdk::{json_types::U128, AccountId};
-use templar_common::{interest_rate_strategy::InterestRateStrategy, number::Decimal};
 use test_utils::{
-    controller::vault::UnifiedVaultController, setup_test, ContractController, MarketController,
-    UnifiedMarketController,
+    setup_test, ContractController,
 };
 
 // TODO(unit?): on allocation-failure, reconcile to idle