address lints

Author: JohnReedV

Cargo.lock

@@ -21,6 +21,7 @@ frame-system = { workspace = true,  default-features = false }
 sp-core = { workspace = true,  default-features = false }
 sp-io = { workspace = true,  default-features = false}
 sp-runtime = { workspace = true, default-features = false}
+subtensor-macros = { workspace = true }
 
 [dev-dependencies]
 pallet-balances = { default-features = true, workspace = true }

pallets/utility/Cargo.toml

@@ -69,6 +69,8 @@ use sp_io::hashing::blake2_256;
 use sp_runtime::traits::{BadOrigin, Dispatchable, TrailingZeroInput};
 pub use weights::WeightInfo;
 
+use subtensor_macros::freeze_struct;
+
 pub use pallet::*;
 
 #[frame_support::pallet]
@@ -133,14 +135,19 @@ pub mod pallet {
         /// The limit on the number of batched calls.
         fn batched_calls_limit() -> u32 {
             let allocator_limit = sp_core::MAX_POSSIBLE_ALLOCATION;
-            let call_size =
-                ((core::mem::size_of::<<T as Config>::RuntimeCall>() as u32 + CALL_ALIGN - 1)
-                    / CALL_ALIGN)
-                    * CALL_ALIGN;
-            // The margin to take into account vec doubling capacity.
-            let margin_factor = 3;
-
-            allocator_limit / margin_factor / call_size
+            let size = core::mem::size_of::<<T as Config>::RuntimeCall>() as u32;
+
+            let align_up = size.saturating_add(CALL_ALIGN.saturating_sub(1));
+            let call_size = align_up
+                .checked_div(CALL_ALIGN)
+                .unwrap_or(0)
+                .saturating_mul(CALL_ALIGN);
+
+            let margin_factor: u32 = 3;
+
+            let after_margin = allocator_limit.checked_div(margin_factor).unwrap_or(0);
+
+            after_margin.checked_div(call_size).unwrap_or(0)
         }
     }
 
@@ -184,7 +191,7 @@ pub mod pallet {
         /// event is deposited.
         #[pallet::call_index(0)]
         #[pallet::weight({
-			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(&calls);
+			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(calls);
 			let dispatch_weight = dispatch_weight.saturating_add(T::WeightInfo::batch(calls.len() as u32));
 			(dispatch_weight, dispatch_class)
 		})]
@@ -296,7 +303,7 @@ pub mod pallet {
         /// - O(C) where C is the number of calls to be batched.
         #[pallet::call_index(2)]
         #[pallet::weight({
-			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(&calls);
+			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(calls);
 			let dispatch_weight = dispatch_weight.saturating_add(T::WeightInfo::batch_all(calls.len() as u32));
 			(dispatch_weight, dispatch_class)
 		})]
@@ -395,7 +402,7 @@ pub mod pallet {
         /// - O(C) where C is the number of calls to be batched.
         #[pallet::call_index(4)]
         #[pallet::weight({
-			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(&calls);
+			let (dispatch_weight, dispatch_class) = Pallet::<T>::weight_and_dispatch_class(calls);
 			let dispatch_weight = dispatch_weight.saturating_add(T::WeightInfo::force_batch(calls.len() as u32));
 			(dispatch_weight, dispatch_class)
 		})]
@@ -496,6 +503,7 @@ pub mod pallet {
 }
 
 /// A pallet identifier. These are per pallet and should be stored in a registry somewhere.
+#[freeze_struct("7e600c53ace0630a")]
 #[derive(Clone, Copy, Eq, PartialEq, Encode, Decode)]
 struct IndexedUtilityPalletId(u16);
 

pallets/utility/src/lib.rs

@@ -39,6 +39,7 @@ type BlockNumber = u64;
 
 // example module to test behaviors.
 #[frame_support::pallet(dev_mode)]
+#[allow(clippy::large_enum_variant)]
 pub mod example {
     use frame_support::{dispatch::WithPostDispatchInfo, pallet_prelude::*};
     use frame_system::pallet_prelude::*;
@@ -127,14 +128,14 @@ type Block = frame_system::mocking::MockBlock<Test>;
 frame_support::construct_runtime!(
     pub enum Test
     {
-        System: frame_system,
-        Timestamp: pallet_timestamp,
-        Balances: pallet_balances,
-        RootTesting: pallet_root_testing,
-        Council: pallet_collective::<Instance1>,
-        Utility: utility,
-        Example: example,
-        Democracy: mock_democracy,
+        System: frame_system = 1,
+        Timestamp: pallet_timestamp = 2,
+        Balances: pallet_balances = 3,
+        RootTesting: pallet_root_testing = 4,
+        Council: pallet_collective::<Instance1> = 5,
+        Utility: utility = 6,
+        Example: example = 7,
+        Democracy: mock_democracy = 8,
     }
 );
 
@@ -174,7 +175,7 @@ parameter_types! {
     pub const MotionDuration: BlockNumber = MOTION_DURATION_IN_BLOCKS;
     pub const MaxProposals: u32 = 100;
     pub const MaxMembers: u32 = 100;
-    pub MaxProposalWeight: Weight = sp_runtime::Perbill::from_percent(50) * BlockWeights::get().max_block;
+    pub MaxProposalWeight: Weight = BlockWeights::get().max_block.saturating_div(2);
 }
 
 pub struct MemberProposals;
@@ -255,19 +256,19 @@ use pallet_timestamp::Call as TimestampCall;
 pub fn new_test_ext() -> sp_io::TestExternalities {
     let mut t = frame_system::GenesisConfig::<Test>::default()
         .build_storage()
-        .unwrap();
+        .expect("Failed to build storage for test");
     pallet_balances::GenesisConfig::<Test> {
         balances: vec![(1, 10), (2, 10), (3, 10), (4, 10), (5, 2)],
     }
     .assimilate_storage(&mut t)
-    .unwrap();
+    .expect("Failed to build storage for test");
 
     pallet_collective::GenesisConfig::<Test, Instance1> {
         members: vec![1, 2, 3],
         phantom: Default::default(),
     }
     .assimilate_storage(&mut t)
-    .unwrap();
+    .expect("Failed to build storage for test");
 
     let mut ext = sp_io::TestExternalities::new(t);
     ext.execute_with(|| System::set_block_number(1));
@@ -688,7 +689,7 @@ fn batch_all_handles_weight_refund() {
         assert_err_ignore_postinfo!(result, "The cake is a lie.");
         assert_eq!(
             extract_actual_weight(&result, &info),
-            info.weight - diff * batch_len
+            info.weight.saturating_sub(diff.saturating_mul(batch_len))
         );
 
         // Partial batch completion
@@ -702,7 +703,7 @@ fn batch_all_handles_weight_refund() {
         assert_eq!(
             extract_actual_weight(&result, &info),
             // Real weight is 2 calls at end_weight
-            <Test as Config>::WeightInfo::batch_all(2) + end_weight * 2,
+            <Test as Config>::WeightInfo::batch_all(2).saturating_add(end_weight.saturating_mul(2)),
         );
     });
 }