From 6fd700e54f69111874a63fa0a6c001906bf94389 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 3 Dec 2024 12:33:24 -0300
Subject: [PATCH 01/30] Print info

---
 apps/cargo-scout-audit/src/cli/mod.rs                     | 3 +++
 apps/cargo-scout-audit/src/detectors/builder.rs           | 7 ++++++-
 apps/cargo-scout-audit/src/scout/nightly_runner.rs        | 8 ++++----
 apps/cargo-scout-audit/src/startup.rs                     | 4 +++-
 apps/cargo-scout-audit/src/utils/print.rs                 | 8 ++++++++
 .../assert-violation/vulnerable/vulnerable-1/src/lib.rs   | 1 +
 6 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/apps/cargo-scout-audit/src/cli/mod.rs b/apps/cargo-scout-audit/src/cli/mod.rs
index c5b45d41..b7a48447 100644
--- a/apps/cargo-scout-audit/src/cli/mod.rs
+++ b/apps/cargo-scout-audit/src/cli/mod.rs
@@ -3,6 +3,8 @@ use clap::{Parser, Subcommand, ValueEnum};
 use std::path::PathBuf;
 use thiserror::Error;
 
+use crate::utils::print::print_info;
+
 #[derive(Debug, Parser)]
 #[clap(display_name = "cargo")]
 pub struct Cli {
@@ -148,6 +150,7 @@ impl Scout {
     }
 
     pub fn validate(&self) -> Result<()> {
+        print_info("Validating CLI arguments...");
         if let Some(path) = &self.output_path {
             if path.is_dir() {
                 bail!(CliError::OutputPathIsDirectory(path.clone()));
diff --git a/apps/cargo-scout-audit/src/detectors/builder.rs b/apps/cargo-scout-audit/src/detectors/builder.rs
index 4c2ff2b6..af3f2207 100644
--- a/apps/cargo-scout-audit/src/detectors/builder.rs
+++ b/apps/cargo-scout-audit/src/detectors/builder.rs
@@ -10,7 +10,10 @@ use super::{
     library::Library,
     source::download_git_repo,
 };
-use crate::{scout::blockchain::BlockChain, utils::telemetry::TracedError};
+use crate::{
+    scout::blockchain::BlockChain,
+    utils::{print::print_info, telemetry::TracedError},
+};
 
 #[derive(Error, Debug)]
 pub enum BuilderError {
@@ -61,12 +64,14 @@ impl<'a> DetectorBuilder<'a> {
 
     #[tracing::instrument(skip_all, level = "debug")]
     pub fn build(&self, bc: &BlockChain, used_detectors: &[String]) -> Result<Vec<PathBuf>> {
+        print_info("Compiling detectors...");
         let all_library_paths = self.build_all_libraries(bc)?;
         self.filter_detectors(&all_library_paths, used_detectors)
     }
 
     #[tracing::instrument(skip_all, level = "debug")]
     pub fn get_detector_names(&self) -> Result<Vec<String>> {
+        print_info("Getting detector names...");
         let mut all_names = Vec::new();
         let libraries = self.get_all_libraries()?;
 
diff --git a/apps/cargo-scout-audit/src/scout/nightly_runner.rs b/apps/cargo-scout-audit/src/scout/nightly_runner.rs
index fc42edad..2affa3c4 100644
--- a/apps/cargo-scout-audit/src/scout/nightly_runner.rs
+++ b/apps/cargo-scout-audit/src/scout/nightly_runner.rs
@@ -1,5 +1,5 @@
-#![allow(unused_imports)]
-use anyhow::{anyhow, Context, Result};
+use crate::utils::print::{print_error, print_info};
+use anyhow::{Context, Result};
 use current_platform::CURRENT_PLATFORM;
 use lazy_static::lazy_static;
 use std::{
@@ -8,8 +8,6 @@ use std::{
     process::{Child, Command},
 };
 
-use crate::utils::print::print_error;
-
 lazy_static! {
     static ref LIBRARY_PATH_VAR: &'static str = match env::consts::OS {
         "linux" => "LD_LIBRARY_PATH",
@@ -40,6 +38,7 @@ pub fn run_scout_in_nightly(toolchain: &str) -> Result<Option<Child>> {
     unsafe {
         let _ = SetDllDirectoryW(PCWSTR(directory.as_ptr()));
     }
+    print_info("Re-running scout with nightly toolchain...");
     return Ok(None);
 }
 
@@ -72,5 +71,6 @@ pub fn run_scout_in_nightly(toolchain: &str) -> Result<Option<Child>> {
     let child = command
         .spawn()
         .with_context(|| "Failed to spawn scout with nightly toolchain")?;
+    print_info("Re-running scout with nightly toolchain...");
     Ok(Some(child))
 }
diff --git a/apps/cargo-scout-audit/src/startup.rs b/apps/cargo-scout-audit/src/startup.rs
index ae6209a4..cd6b4b69 100644
--- a/apps/cargo-scout-audit/src/startup.rs
+++ b/apps/cargo-scout-audit/src/startup.rs
@@ -18,7 +18,7 @@ use crate::{
         config::{open_config_and_sync_detectors, profile_enabled_detectors},
         detectors::{get_excluded_detectors, get_filtered_detectors, list_detectors},
         detectors_info::get_detectors_info,
-        print::{print_error, print_warning},
+        print::{print_error, print_info, print_warning},
     },
 };
 use anyhow::{anyhow, bail, Context, Ok, Result};
@@ -254,6 +254,8 @@ fn run_dylint(
     opts: &Scout,
     inside_vscode: bool,
 ) -> Result<(bool, NamedTempFile)> {
+    print_info("Running scout...");
+
     // Convert detectors paths to string
     let detectors_paths: Vec<String> = detectors_paths
         .iter()
diff --git a/apps/cargo-scout-audit/src/utils/print.rs b/apps/cargo-scout-audit/src/utils/print.rs
index ece63825..6a9e4273 100644
--- a/apps/cargo-scout-audit/src/utils/print.rs
+++ b/apps/cargo-scout-audit/src/utils/print.rs
@@ -8,6 +8,10 @@ pub fn print_error(message: &str) {
     println!("{}", pretty_error(message));
 }
 
+pub fn print_info(message: &str) {
+    println!("{}", pretty_info(message));
+}
+
 pub fn pretty_warning(message: &str) -> String {
     format!("{} {}", "[WARNING]".yellow(), message)
 }
@@ -15,3 +19,7 @@ pub fn pretty_warning(message: &str) -> String {
 pub fn pretty_error(message: &str) -> String {
     format!("{} {}", "[ERROR]".red(), message)
 }
+
+pub fn pretty_info(message: &str) -> String {
+    format!("{} {}", "[INFO]".blue(), message)
+}
diff --git a/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
index 084c695a..5e6ff5b3 100644
--- a/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
@@ -39,6 +39,7 @@ pub mod pallet {
         #[pallet::call_index(0)]
         pub fn unsafe_check_balance(origin: OriginFor<T>, amount: u32) -> DispatchResult {
             let who = ensure_signed(origin)?;
+            ensure_none(who);
             assert!(
                 BalanceStorage::<T>::get().unwrap_or(0) >= amount,
                 "Insufficient balance"

From 791e532d5517ea293e5f8336d3bcbade3f7275f1 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 3 Dec 2024 14:34:58 -0300
Subject: [PATCH 02/30] Add test-cases and detector

---
 detectors/substrate-pallets/Cargo.lock        | 10 +++
 .../unsigned-extrinsic/Cargo.toml             | 16 ++++
 .../unsigned-extrinsic/src/lib.rs             | 89 +++++++++++++++++++
 test-cases/substrate-pallets/Cargo.lock       | 30 +++++++
 .../remediated/remediated-1/Cargo.toml        | 34 +++++++
 .../remediated/remediated-1/src/lib.rs        | 63 +++++++++++++
 .../remediated/remediated-1/src/weights.rs    | 23 +++++
 .../vulnerable/vulnerable-1/Cargo.toml        | 34 +++++++
 .../vulnerable/vulnerable-1/src/lib.rs        | 63 +++++++++++++
 .../vulnerable/vulnerable-1/src/weights.rs    | 23 +++++
 10 files changed, 385 insertions(+)
 create mode 100644 detectors/substrate-pallets/unsigned-extrinsic/Cargo.toml
 create mode 100644 detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/weights.rs

diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index b98c6ba7..8de9c7b0 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -2846,6 +2846,16 @@ dependencies = [
  "if_chain",
 ]
 
+[[package]]
+name = "unsigned-extrinsic"
+version = "0.1.0"
+dependencies = [
+ "clippy_utils",
+ "common",
+ "dylint_linting",
+ "if_chain",
+]
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
diff --git a/detectors/substrate-pallets/unsigned-extrinsic/Cargo.toml b/detectors/substrate-pallets/unsigned-extrinsic/Cargo.toml
new file mode 100644
index 00000000..3b934ec9
--- /dev/null
+++ b/detectors/substrate-pallets/unsigned-extrinsic/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+edition = "2021"
+name = "unsigned-extrinsic"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+clippy_utils = { workspace = true }
+common = { workspace = true }
+dylint_linting = { workspace = true }
+if_chain = { workspace = true }
+
+[package.metadata.rust-analyzer]
+rustc_private = true
diff --git a/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
new file mode 100644
index 00000000..7e01f7ea
--- /dev/null
+++ b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
@@ -0,0 +1,89 @@
+#![feature(rustc_private)]
+
+extern crate rustc_errors;
+extern crate rustc_hir;
+extern crate rustc_span;
+
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, source::snippet};
+use common::{
+    declarations::{Severity, VulnerabilityClass},
+    macros::expose_lint_info,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{
+    def_id::LocalDefId,
+    intravisit::{walk_expr, FnKind, Visitor},
+    Body, Expr, ExprKind, FnDecl, QPath,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_span::{Span, Symbol};
+
+const LINT_MESSAGE: &str = "Using unsigned extrinsics without fees exposes the chain to potential DoS attacks";
+
+#[expose_lint_info]
+pub static UNSIGNED_EXTRINSIC_INFO: LintInfo = LintInfo {
+    name: env!("CARGO_PKG_NAME"),
+    short_message: LINT_MESSAGE,
+    long_message: "Unsigned extrinsics allow transactions to be submitted without any associated fees \
+                   or signatures. This can be exploited by malicious actors to flood the network with \
+                   transactions at no cost, potentially causing denial of service. Consider using signed \
+                   extrinsics with appropriate fee mechanisms unless there's a specific security reason \
+                   for allowing unsigned transactions.",
+    severity: Severity::Critical,
+    help: "https://coinfabrik.github.io/scout-substrate/docs/detectors/unsigned-extrinsic",
+    vulnerability_class: VulnerabilityClass::DoS,
+};
+
+dylint_linting::declare_late_lint! {
+    pub UNSIGNED_EXTRINSIC,
+    Warn,
+    LINT_MESSAGE
+}
+
+struct UnsignedExtrinsicVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UnsignedExtrinsicVisitor<'a, 'tcx> {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            // Ignore expressions from proc macros
+            if !is_from_proc_macro(self.cx, expr);
+            // Check if the expression is `ensure_none`
+            if let ExprKind::Call(callee, args) = &expr.kind;
+            if let ExprKind::Path(QPath::Resolved(None, path)) = &callee.kind;
+            if path.segments.len() == 1;
+            if path.segments[0].ident.name == Symbol::intern("ensure_none");
+            then {
+                let first_arg_str = snippet(self.cx, args[0].span, "..");
+                span_lint_and_sugg(
+                    self.cx,
+                    UNSIGNED_EXTRINSIC,
+                    expr.span,
+                    LINT_MESSAGE,
+                    "consider signing this extrinsic to prevent DoS attacks",
+                    format!("ensure_signed({})", first_arg_str),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+
+        walk_expr(self, expr);
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnsignedExtrinsic {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        _: Span,
+        _: LocalDefId,
+    ) {
+        let mut visitor = UnsignedExtrinsicVisitor { cx };
+        walk_expr(&mut visitor, body.value);
+    }
+}
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 4e05a56d..458317d2 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -3541,6 +3541,36 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "unsigned-extrinsic-remediated-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "unsigned-extrinsic-vulnerable-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/Cargo.toml b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/Cargo.toml
new file mode 100644
index 00000000..1927b1a9
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "unsigned-extrinsic-remediated-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-support/std",
+    "frame-system/std",
+    "log/std",
+    "pallet-balances/std",
+    "scale-info/std",
+    "sp-core/std",
+    "sp-io/std",
+    "sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/lib.rs
new file mode 100644
index 00000000..f2afa14c
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/lib.rs
@@ -0,0 +1,63 @@
+// lib.rs
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub use pallet::*;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn balance_storage)]
+    pub type BalanceStorage<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn safe_call(origin: OriginFor<T>) -> DispatchResult {
+            let _ = ensure_signed(origin)?;
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    pub enum Event<T: Config> {}
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        #[serde(skip)]
+        pub _phantom: PhantomData<T>,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            BalanceStorage::<T>::put(0);
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/weights.rs b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/weights.rs
new file mode 100644
index 00000000..b199e02d
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/remediated/remediated-1/src/weights.rs
@@ -0,0 +1,23 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn safe_call() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn safe_call() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+	}
+}
+
+impl WeightInfo for () {
+	fn safe_call() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+	}
+}
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/Cargo.toml
new file mode 100644
index 00000000..70a765b3
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "unsigned-extrinsic-vulnerable-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-support/std",
+    "frame-system/std",
+    "log/std",
+    "pallet-balances/std",
+    "scale-info/std",
+    "sp-core/std",
+    "sp-io/std",
+    "sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/lib.rs
new file mode 100644
index 00000000..3d8747b8
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/lib.rs
@@ -0,0 +1,63 @@
+// lib.rs
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub use pallet::*;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn balance_storage)]
+    pub type BalanceStorage<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn unsafe_call(origin: OriginFor<T>) -> DispatchResult {
+            ensure_none(origin)?;
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    pub enum Event<T: Config> {}
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        #[serde(skip)]
+        pub _phantom: PhantomData<T>,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            BalanceStorage::<T>::put(0);
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/weights.rs b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/weights.rs
new file mode 100644
index 00000000..8cdda511
--- /dev/null
+++ b/test-cases/substrate-pallets/unsigned-extrinsic/vulnerable/vulnerable-1/src/weights.rs
@@ -0,0 +1,23 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn unsafe_call() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn unsafe_call() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+	}
+}
+
+impl WeightInfo for () {
+	fn unsafe_call() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+	}
+}

From 858d98837b7e2c2fa5e6eec413c183ab99031690 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 3 Dec 2024 14:39:44 -0300
Subject: [PATCH 03/30] Only use last segment of the call

---
 detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
index 7e01f7ea..411c3bc9 100644
--- a/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
+++ b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
@@ -19,7 +19,8 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::{Span, Symbol};
 
-const LINT_MESSAGE: &str = "Using unsigned extrinsics without fees exposes the chain to potential DoS attacks";
+const LINT_MESSAGE: &str =
+    "Using unsigned extrinsics without fees exposes the chain to potential DoS attacks";
 
 #[expose_lint_info]
 pub static UNSIGNED_EXTRINSIC_INFO: LintInfo = LintInfo {
@@ -53,8 +54,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsignedExtrinsicVisitor<'a, 'tcx> {
             // Check if the expression is `ensure_none`
             if let ExprKind::Call(callee, args) = &expr.kind;
             if let ExprKind::Path(QPath::Resolved(None, path)) = &callee.kind;
-            if path.segments.len() == 1;
-            if path.segments[0].ident.name == Symbol::intern("ensure_none");
+            if let Some(last_segment) = path.segments.last();
+            if last_segment.ident.name == Symbol::intern("ensure_none");
             then {
                 let first_arg_str = snippet(self.cx, args[0].span, "..");
                 span_lint_and_sugg(

From 169ca12af110f26aae33b949614b0729aa8ef99a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Wed, 4 Dec 2024 09:35:50 -0300
Subject: [PATCH 04/30] Delete incorrectly added file.

---
 test-cases/substrate-pallets/basic.tar | Bin 20480 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 test-cases/substrate-pallets/basic.tar

diff --git a/test-cases/substrate-pallets/basic.tar b/test-cases/substrate-pallets/basic.tar
deleted file mode 100644
index b7d171bec9d29a9fd0a3aa7e5c93dd761b817b12..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 20480
zcmeHOdsExUme0TAPtlO7tek5c+Zf0y9;Wgjcc`5tvw=Hzw^Ec!NNrGIOTKypxP<S%
zzjL}<YRNJXChTt2g{s7sy8HBb^?A0B{VWPzJbBQ+0seNjww~Z)xU)5|KWT{mo(#u3
zgYB)&!FXr*WH20VjmJ;K)`McDffrfsr$RjW8U=ZhuHNys@zpE;UymHK{NMWNNz%`g
z`RpN(B>`_kp!jH$|8RS_Q_6p9umkyTZViS{#NZ*2X~O&$m;aZAADsCo@~9L0b18ln
z>kEH2llg|c@aKz}++YP+?|hYM79}xF813{2{lR+2FY?nQ&HCp_dX@nUt<KXzc4Qdk
zn7ceMivk&Eyvv9E!wtX)Wfr8-f~FJb_n%*X*b{ndp)gtRq|y%+ZlCvFzx%M)pNH$6
zMR7cfvQw;@`m;=SI);+|T;_i0=YBs-f~=orM;)B-6Pah2`(^#&<+isy-YDX;I603u
zW>H*RY@Ec!`Vl~cav|eT#z7>pEJ#8bV9}Lmk|?e_v*cveP!{-LTog|eo-vhvUZhfO
zAIdcPD%X#CZ7`=PWUz6J{ZHq9dKSfMi-h^(&j5}1d&APKSS*q>Uxk>0pIv6ToUfXr
z#eeM2{5W8wTglHB8<8Tfg*O;Xi#U&1XsyeM)n7O2?8d4fNl80aEHR8cg4#^|Vn%d+
zS<mtivcv!M)cI+hrS^i}_VBdK(q9^5nrF?o%%t)qq+Nb*aHxD=iM@KINV1=!#D3Cj
z(yxv>P3!dF&&vL1=|jc<WdHB#|F^c`Cx)ZV&Fx43|KP&M29^BJWpr|ylfnGa`;z=`
z@c*Oj&9U+S!@+n2`HwfZHXr@}kCsClyr*klg6WCp=XvU+h=r!}yeIS*FFT7C-J=fX
zASOu8ogywW8F~vpg&S`fi00&dXrzOQf^Dy-?W^lv<*6U#nd|;lVh^ouc>Q-)yq*Y>
z7_oRvGd?H5S@!N&ja*;9VsPXfT$dc9OkMZ)Q%p_f@8IZPbtoEuZv=Ru*6fq>z3Til
zjYTGNFD&NsORsdSPFHN~>Y1;2k{<-cyqNj9RCAYSWT4FZDk({DE?iM;j(Va7=2~Hq
z!9@qTI4F+s4e%5`lfzxd!WfU;R~@ixHaT<+pV;HL?%O1uMkfY6CS;nVEdcLEAI<tn
zA>q2yG?|n5^2{0jyN6@R|BCH#PYk-4_ftQkSjEo~dU$>qI)|=n#NfJ!p`332JdJXR
z^&XaWvFQ3%2ChWm<vmfLfY8F=PoRB^R99g>AmR<rUc3+o(A&^YL$Q~pN$QGG8!uag
zur(?n*_?+aIv2vvM9E?(7io*F-J}#y(>p2oDmw0_1hv!nf29VkNZhIjt*hEK_(!OM
zEkrs#e@^6W_WDP^tNi~gI(`7(Px#*K|A$*UJ7xW6xIN<hf4sf*=>LDTtlQw({y$D~
zN9S0`r8u$b_C%a`NT$fA%Zps5u?Wbm35o~;cwTb!{M~io9bNYiiMRBU^DwygcapyK
z#9mCFxBK$8$e|<f7e=Tu<iROmzMc757ELeT=~q2rzVS%)_*rJi6MN!!|1wkmzn8#;
z&n1Np*F6SpB9r|Le*5rpA=T@16%xCyI>)_^#$E?D+F>IWLVE9I(Mc>rMLW_(*QEl0
zdgRQ|qi5G8=;YM($imYpAgHRLa`h%DP>KjET4>d$X-^y|7cE0X3c4&)zJ%Y#cgAE7
z(u%2OQ_&b_en6!b@2fwHP^7sun-Y8XV}5&>`es^BSPy^bC9N;n?ezrDvDPRqVt??B
zLo|}DN}pZ#Io>^`;L|}kkwd@cNhs)RrYF<0mcXlWbtw{Bo`aX-jjB|9nj)xz+D;D1
zajH!`Q^hEwD%aK1U!l5#a8rEP|LwQ^w|gHC4>+a+fMFSwz;0m^9ndKic%P&PGJi+m
zBt>qkwsCBv5b2en-l_$aMoye(_TpZ5SCFS~*?t#Zodky%m$~9m(aU+3$r+SHmAqWh
zgl2`TdO3kW!A~IQ$fLz9k|~%#K>DDb2I&tm&T|E_KM+wS@>87pIW#l}4>BYLB0@CI
zuVE$92#Ob!iwQake_Vj8pu7+ho6ubqojR33z&EwI(A3xBS4Tm7ZsFZE?iV=<q2sy}
z1W>yUj2NO@f_2@|fz(aH6HV)KFOdY=M0v(+-AOVvGiC`Wnp*tdZRgw&`iiuKLPEng
z`mBL;-A@Zi@qH5evvS(CkSL+vyzXO?&g~`N!A~;2FuV6+;{t2Fsg#C$-i?Y)J6UAV
zqwD^+%qnD`eraT->O>x~fgy{do;47%SIA!}--Nv(Znk(QeWn+woE0H5)a9AlQLLEw
z6qRc#xw|e*5>me--l)oGRYJJZ*oeQhCXf~zY8!Bht+pU~*o1!YPom&sF+T>O0@?ZG
z0LQ;HmAkNCG?o5%`e#+!-TR6&?TYuvDJT4$m+kHXq5X{9+=O3{Ij%cQMGy|W4QOc>
zW%0=Ax%&Jow@GN=6w^mVnBri?Ic>CmXU0<U?U5C(uQ^SUGgSHMrOCuKX5v>Gn!G`T
zbEen=yALSJ6qi6P7Q+U^twu2#AMlg^l#Um>VrhN5@g)Qlv99}1nI?|1RrFfZNnh0t
z(+KDG2KZNv71L>O>PN9hMS7X8!V0Ub-72o4k1=!Dx8#oUtEK2F>2%?`X?2r_ZEUK8
z2ERgi;S4kY0zz63N|(wpNgAC*VCg6RRMP0d=LE<AGwB^)x&oyN?N6A^#_XvG&=M7G
zLmtV?sMSNxt`@*KYOC%qme$jfiFW$C(A#;DBLsH7aarkG1Ga%5%X3vr!VWyKKlc|N
zsz(;qJ@GC4CPL%4Ox4Aj(Y3rFL8iaw3=UuqlDTxseHt^bjmE1*La0NHo=cKNxhLuL
zI_eC&ugmfmQ`th%v5K->o98OLGvJr@`*h|wC=iw7l@)1KgQ2Ac)da15O5LpJ3%(tv
zx;27;A0#(u^pf`1YE_m3of0b=ZB?$?j0&G1nWNR29|>YR0_H;6npbh;b{*7OmnO)%
zR_I&=<G1Flf0XBfx1z`kT}xM7xxZYmBQ-NPG(~MI>!Qe6M;JnL;te`s;#_p&O5v9q
zirb}4oL#chtaZv>R6ISAF~uY(y(-;wATEd9ZkLQfO=Go^kU(Wz%!P712*r)*u7aPN
zmAa%!8x77MD*5T8iHN8eQPYX<0`LZROe)L>Doh-O&#XPbl)mqW)&4Z)ZaXaTI75k=
zJNg8}VkP@-KHn7m8h*iwsQF0V3OVtR-<5{c_~c4dH^K&yt&l(X3xfM*=AX%tHypjh
z-hq#-96ME{-+$ltNz%G+3q_ox7V<v}nO@#boeFo}l5Av1RB(o=pEcW75?8$JiDJ0D
zybGy&7G+*wMSD-t52uR(P9r*fryAWK6RrkW%C7^QzbaTtm^KqCWuv3Q4x`;r(eSa4
zxDSP!3Dx^sCDPrkRFhUr6GUZ|qNu?oO*E7q7tt(ij}qR{P>l*scWZBm?G-(+2n<hU
z1kG%xY56#jW%3*Dk&<f1?}_6sT$<plxeq>A8`1HhKR6i<{-~mp$uw81Ue%0&3ZT?{
ztYD3#NP&zmqX33k2&n0`Y}A~`X4v#p_ufMEJfJe6)Jjl~k^o*i5f+OMtW~sh&p7Ej
zV<ei66zD6$5>U_XS+@!*PSG4(gi$v)s#zwSx@d+{&o2P&;-=`Rf=#@Ceo+dA{F4y}
z6)4ht&0+NZVn;CI=btq~wqvvc7Zy=@I8_M~6**nfd^<~Gs%-v)N{cCl{`8enA4*jq
zsHb15(w{@!RF8}>b>RGY<{VOpLZ``;n5eqhFwjV*4iKl($7LL}G!e_vl2V|?d{kkn
zX^O5c8hP@#I8ntUYa?^Cpih`(((I`#o<S`3as*#<w25WPp^XK1DZ=Ld%9?{J)cW7c
zoz`0_FzqNe%9qO+cg{~`Dp|ZLE4ewne2Xl`MM|nmyAyh*WUkk_Vi*Az0{7pc2)O@#
zfA2F$|2JgGc@&Ufpn*0ON~_qFmWC2jY`bYqp{+1_S1hfSuS0c-&YvlE0E(kknm7NQ
zFG|rXrh%+Mxk8tsje$g~TS-eDJ*3@y1SeD%vx>FwmRu9&TCULwIzqMMV0Ob<sw!Lj
zlBSZWs~pAoDV)SJ6=Igms)i}MEXRpc)er@~7&18=ohHO*3KGq<ywOY|Ei5wR#A-Qf
zr>0OX0ITjsC}H16m>i*yDji^tI|+mqEXEYyu~V0FIOm)94Z<+`Y&cRbEV-ddvE`$8
ze}1Um!JlAAi<~V_hw37T6T4zG7+9}KqN&7vfVibO;JSMkr#^0sWMFnuq_`{Cr=qLT
zQd(>kBVam$Q)Xu$p-)yEvnAyIHO(}CoY9hmUAIiukbw02NI1mLwpN-InbkpApzxeK
z>($D0)SglqNJLg)f887wvy?u`C9&kZoSY3G0*hG<ZkUzW2q_!-Cqj2==w8Z&$_H_*
zN|BrS^x5z0V9s^*^+l`DV<w_eV!oPB96y6#l}yuMJ?8L;J(#<^iG@!UcbHya)&J$z
z%Y$@)Z|VOI#^Ygm|4a3M$M_w<WB=F4=pjF;o~;|YW!FsKzee{AT^!xarTm;r+bsp~
zE7n;RWqHY24;ee<G9Fa~)maFu)~#*RdsJ+;UsSD1z9@Eu03pl&Mptb<#rtJ(RW%g3
zHorhfOaacXqpj`RJF1j`9-b$d+Y|e^=AGjR|Ata;vCtcHHlh<d)wN`2%Y|H6hkBeb
zM|Bt#JJ<byFFa*(i1sBVe2pxQBMiD0W}3ZgssKf?A6GGG9Wzm}l1}%5Y8uq`tPG1T
zT4YOIfojU0y1-w~s7X~#yY7%lG~q4F%Os$>WdY35k?`Q{skeb<3Sp{E41|L*gs^-w
zsm>cU#-SUn&}LLI69rqc@b9A;g2{@j>gu}d=K7W(Dm&?AehLm-VG*-g6$9x$y>T{`
zlzx-(Nlw2Cs12DrY|ZzzJPCufXKUM!C|J<NbhHz#x4-)Q`vawWBr`@s!ypnXi1gH0
z3BoYWMG>Ww)_55$E$yk)6|d|1t7D^b9h9&{$Y?KrTJJTYTtTZa<wtAQALS1}Y8+K*
zDg|a(T0K|`H7<0^0#g=X04`$ck`@%n8s;vowenMpil-jO(%QbC;{S*MDO@qEPEFOE
zXf8iE*m{Y0a2k=bZvaM}?=AA{=D-L40@|Dvb1(v9jiYU}m8Rr>+Z;`};)B4aeyWzp
z5AJ-hmX_Xdwlr7Bf)O2x8?Q{$Ti5(rPo>oY#6m^Q_IOge3}GwP-IQlZ5MT_Kk7BM}
z=P(T(?hB~fwus~+x*&s>bay4CPFIc};%MVRksAHtL+@Ox5LscG`gMzo9G!n6Vg*~3
zX)Lwy##!26wi{5o#mr?qEsd*M+@|Yo<59II9Y?OS;UFZqCxy#WYhRpUPmGX;Ik-%`
z**&VyMokAdNypVo?W9x?*XJS_u4ZwuSBH}QB0f)%p_oijN93dcPrneik2=T{(f#2c
z?RcnxdFIDOCV17Xq)LA!p1!=0L4gYWd6b_z-|RY#4xopS%y^^@F_EfYkMMf5Q@z$f
zg8avt!-Wp269Fw$%J_0I?k-VF3-Rud8eb((%h+PgF>cNE%bu0KvaJ<E6}^x@@GU53
z2=)RV`a$=>0_7C5xI|{6QJ}`Q9hR^e110rF@MwA8<m}#LFk6Vf^mlh=YBJPE34>~6
zH)w{=Qtqo57IwPSR}=JTe0Rp+Bsi<3Thi0uN$aj#de>#z%dAlyjxsg<u9Lt=1{wpk
zA8u|gX<SY6<%Uh#xFra+HNd`Kb(<?&sO8f^#@9Qi)Lj2Wg6+cnNDoxNquo_4+Qjuc
z4AxWnvX$tH;Xqt3)egvjP~8Qbv@-<Do-f-6GArdVC2gq6kH*m0zrv`e(=@-T{yc+a
zenuqWLzRDqTlx|iO*DU{!L4meqkU5&sO&erMg)n3;q`x2Z<mk3_mXiF)+1nD?L`<Y
z-}78u%BfbC$EIO1xN(X5cBqTp_uN>9qH47ndC{dPwBOVnzUn-+P1N0)O>(8x%)3G#
zuA=Z<T>@t6%9BCbY3$=26yG?xrq4oY%ew2KPJ%++s6Y8td!s)5WLbFSvY>JHiqJJ&
zFPSF8zQVeXP}ig1;R5kpT!K`vEtZsOYp<%L&UllbQ&A3_TNTl{%N|%ADD1*uiG%<J
zLj2_DJ6Kd&MexS55hK`$I%g=fu)zNr#t`wNWtM@E>;L^<<UVAz=MnZJ2Oc@_$bm-=
XJaXWX1CJbd<iH~b9y#!@%z^&_v%gXv


From 65769b268756f5f95d221929c2f5158448453953 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Wed, 4 Dec 2024 09:37:19 -0300
Subject: [PATCH 05/30] Update .gitignore.

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index e32934bb..baba65c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -53,9 +53,10 @@ report.md
 env/
 venv/
 !/detectors/ink/.vscode/
-__pycache__
+__pycache__
 
 .vs
 /scripts/cs/run-tests/bin/
 /scripts/cs/run-tests/obj/
 launchSettings.json
+basic.tar

From 80d1ce3bbd1f3d33c391cade95dd8b1bcde16f05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Wed, 4 Dec 2024 09:49:31 -0300
Subject: [PATCH 06/30] Added test cases.

---
 .../vulnerable/vulnerable-1/Cargo.toml        |  41 +++
 .../vulnerable/vulnerable-1/src/lib.rs        | 247 ++++++++++++++++++
 .../vulnerable/vulnerable-1/src/tests.rs      | 153 +++++++++++
 .../vulnerable/vulnerable-1/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-2/Cargo.toml        |  41 +++
 .../vulnerable/vulnerable-2/src/lib.rs        | 218 ++++++++++++++++
 .../vulnerable/vulnerable-2/src/tests.rs      | 153 +++++++++++
 .../vulnerable/vulnerable-2/src/weights.rs    |  46 ++++
 8 files changed, 945 insertions(+)
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs

diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
new file mode 100644
index 00000000..73ea3b48
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "pallet-satirating-arithmetic-vulnerable-1"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-benchmarking = { optional = true, workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
new file mode 100644
index 00000000..0094aebb
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
@@ -0,0 +1,247 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.map_or(increase_by, |d| d.saturating_add(increase_by));
+                *dummy = Some(new_dummy);
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub(super) type Bar<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, T::Balance>;
+
+    #[pallet::storage]
+    pub(super) type Foo<T: Config> = StorageValue<_, T::Balance, ValueQuery>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+        pub bar: Vec<(T::AccountId, T::Balance)>,
+        pub foo: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+            for (a, b) in &self.bar {
+                <Bar<T>>::insert(a, b);
+            }
+            <Foo<T>>::put(self.foo);
+        }
+    }
+}
+
+impl<T: Config> Pallet<T> {
+    #[allow(dead_code)]
+    fn accumulate_foo(origin: T::RuntimeOrigin, increase_by: T::Balance) -> DispatchResult {
+        let _sender = ensure_signed(origin)?;
+
+        let prev = Foo::<T>::get();
+        let result = Foo::<T>::mutate(|x| {
+            *x = x.saturating_add(increase_by);
+            *x
+        });
+        assert!(prev + increase_by == result);
+
+        Ok(())
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
new file mode 100644
index 00000000..c424e185
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
@@ -0,0 +1,153 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+            bar: alloc::vec![(1, 2), (2, 3)],
+            foo: 24,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn it_works_for_default_value() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(Foo::<Test>::get(), 24);
+        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
+        assert_eq!(Foo::<Test>::get(), 25);
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
new file mode 100644
index 00000000..a08e6401
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "pallet-satirating-arithmetic-vulnerable-2"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-benchmarking = { optional = true, workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
new file mode 100644
index 00000000..706b2f77
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
@@ -0,0 +1,218 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn multiply_dummy(origin: OriginFor<T>, factor: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                *dummy = dummy.and_then(|d| Some(d.saturating_mul(factor)));
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: factor,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
new file mode 100644
index 00000000..c424e185
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
@@ -0,0 +1,153 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+            bar: alloc::vec![(1, 2), (2, 3)],
+            foo: 24,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn it_works_for_default_value() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(Foo::<Test>::get(), 24);
+        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
+        assert_eq!(Foo::<Test>::get(), 25);
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}

From 44742c3dfefbd9c52cc73d20209608936e1bcbd6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Wed, 4 Dec 2024 11:03:27 -0300
Subject: [PATCH 07/30] Moved decomposers to reusable module.

---
 common/analysis/src/decomposers.rs            | 175 ++++++++++++
 common/analysis/src/lib.rs                    |   2 +
 .../detectors/src/iterators_over_indexing.rs  | 249 +++---------------
 3 files changed, 218 insertions(+), 208 deletions(-)
 create mode 100644 common/analysis/src/decomposers.rs

diff --git a/common/analysis/src/decomposers.rs b/common/analysis/src/decomposers.rs
new file mode 100644
index 00000000..4e45c187
--- /dev/null
+++ b/common/analysis/src/decomposers.rs
@@ -0,0 +1,175 @@
+extern crate rustc_ast;
+extern crate rustc_hir;
+extern crate rustc_middle;
+extern crate rustc_span;
+extern crate rustc_type_ir;
+extern crate rustc_lint;
+
+use rustc_ast::{BindingMode, Label, LitIntType, LitKind};
+use rustc_hir::{
+    def::Res,
+    Block, Expr, ExprField, ExprKind, HirId, LangItem, LoopSource, MatchSource, Pat, PatField,
+    PatKind, Path, QPath, StmtKind, Ty,
+};
+use rustc_middle::ty::{TyCtxt, TyKind};
+use rustc_span::{symbol::Ident, Span};
+use rustc_type_ir::Interner;
+
+pub fn type_to_adt<'hir>(
+    kind: &'hir rustc_type_ir::TyKind<TyCtxt<'hir>>,
+) -> Option<
+    (
+        &'hir <TyCtxt<'hir> as Interner>::AdtDef,
+        &'hir <TyCtxt<'hir> as Interner>::GenericArgs,
+    )
+> {
+    if let TyKind::Adt(a, b) = kind {
+        Some((a, b))
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn stmt_to_expr<'hir>(kind: &'hir StmtKind<'hir>) -> Option<&'hir Expr<'hir>> {
+    if let StmtKind::Expr(a) = kind {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn expr_to_drop_temps<'hir>(kind: &'hir ExprKind<'hir>) -> Option<&'hir Expr<'hir>> {
+    if let ExprKind::DropTemps(a) = kind {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_match<'hir>(
+    kind: &'hir ExprKind<'hir>,
+) -> Option<(&'hir Expr<'hir>, &'hir [rustc_hir::Arm<'hir>], MatchSource)> {
+    if let ExprKind::Match(a, b, c) = kind {
+        Some((a, b, *c))
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_call<'hir>(
+    kind: &'hir ExprKind<'hir>,
+) -> Option<(&'hir Expr<'hir>, &'hir [Expr<'hir>])> {
+    if let ExprKind::Call(a, b) = kind {
+        Some((a, b))
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_path<'hir>(kind: &'hir ExprKind<'hir>) -> Option<QPath<'hir>> {
+    if let ExprKind::Path(a) = kind {
+        Some(*a)
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_struct<'hir>(
+    kind: &'hir ExprKind<'hir>,
+) -> Option<
+    (
+        &'hir QPath<'hir>,
+        &'hir [ExprField<'hir>],
+        Option<&'hir Expr<'hir>>,
+    ),
+> {
+    if let ExprKind::Struct(a, b, c) = kind {
+        Some((a, b, *c))
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_lit<'hir>(kind: &'hir ExprKind<'hir>) -> Option<&'hir rustc_hir::Lit> {
+    if let ExprKind::Lit(a) = kind {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+pub fn expr_to_loop<'hir>(
+    kind: &'hir ExprKind<'hir>,
+) -> Option<(&'hir Block<'hir>, &Option<Label>, LoopSource, &Span)> {
+    if let ExprKind::Loop(a, b, c, d) = kind {
+        Some((a, b, *c, d))
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn path_to_lang_item(path: &QPath) -> Option<(LangItem, Span)> {
+    if let QPath::LangItem(a, b) = path {
+        Some((*a, *b))
+    } else {
+        None
+    }
+}
+
+pub fn path_to_resolved<'hir>(
+    path: &'hir QPath<'hir>,
+) -> Option<(&'hir Option<&'hir Ty<'hir>>, &'hir Path<'hir>)> {
+    if let QPath::Resolved(a, b) = path {
+        Some((a, b))
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn resolution_to_local(resolution: &Res) -> Option<&HirId> {
+    if let Res::Local(a) = resolution {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn lit_to_int(kind: &LitKind) -> Option<(u128, LitIntType)> {
+    if let LitKind::Int(a, b) = kind {
+        Some((a.get(), *b))
+    } else {
+        None
+    }
+}
+
+//---------------------------------------------------------------------
+
+pub fn pattern_to_struct<'hir>(
+    pat: &'hir PatKind<'hir>,
+) -> Option<(&QPath<'hir>, &'hir [PatField<'hir>], bool)> {
+    if let PatKind::Struct(a, b, c) = pat {
+        Some((a, b, *c))
+    } else {
+        None
+    }
+}
+
+pub fn pattern_to_binding<'hir>(
+    pat: &'hir PatKind<'hir>,
+) -> Option<(&BindingMode, &HirId, &Ident, &Option<&'hir Pat<'hir>>)> {
+    if let PatKind::Binding(a, b, c, d) = pat {
+        Some((a, b, c, d))
+    } else {
+        None
+    }
+}
diff --git a/common/analysis/src/lib.rs b/common/analysis/src/lib.rs
index 7d1e5cf0..a65fa211 100644
--- a/common/analysis/src/lib.rs
+++ b/common/analysis/src/lib.rs
@@ -17,3 +17,5 @@ pub use type_utils::*;
 
 mod token_interface_utils;
 pub use token_interface_utils::*;
+
+pub mod decomposers;
diff --git a/common/detectors/src/iterators_over_indexing.rs b/common/detectors/src/iterators_over_indexing.rs
index 9bbbf0b3..cac9fdf8 100644
--- a/common/detectors/src/iterators_over_indexing.rs
+++ b/common/detectors/src/iterators_over_indexing.rs
@@ -1,23 +1,19 @@
-extern crate rustc_ast;
 extern crate rustc_hir;
+extern crate rustc_lint;
 extern crate rustc_middle;
 extern crate rustc_span;
 extern crate rustc_type_ir;
-extern crate rustc_lint;
 
 use std::collections::HashSet;
 
-use rustc_ast::{BindingMode, Label, LitIntType, LitKind};
 use rustc_hir::{
-    def::Res,
     intravisit::{walk_expr, Visitor},
-    Block, Expr, ExprField, ExprKind, HirId, LangItem, LoopSource, MatchSource, Pat, PatField,
-    PatKind, Path, QPath, StmtKind, Ty,
+    Expr, ExprKind, HirId, LangItem, LoopSource, MatchSource,
+    QPath
 };
 use rustc_lint::LateContext;
-use rustc_middle::ty::{TyCtxt, TyKind};
-use rustc_span::{symbol::Ident, Span};
-use rustc_type_ir::Interner;
+use rustc_span::Span;
+use analysis::decomposers::*;
 
 pub struct IteratorsOverIndexingConfig{
     pub check_get: bool,
@@ -47,27 +43,27 @@ pub fn get_node_type<'a>(
 
 #[allow(dead_code)]
 impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
-    fn match_expression(&mut self, kind: &'a ExprKind<'a>) -> Result<(), ()> {
+    fn match_expression(&mut self, kind: &'a ExprKind<'a>) -> Option<()> {
         match kind {
             ExprKind::MethodCall(function_name, object, arguments, _) => {
                 if !self.config.check_get {
-                    return Ok(());
+                    None?;
                 }
                 let name = function_name.ident.name.as_str();
                 if name == "get" || name == "get_unchecked" {
                     self.match_method_call_obj(&object.kind, arguments)
                 }else{
-                    Ok(())
+                    None
                 }
             },
             ExprKind::Index(arr, index, _) => {
                 if !self.config.check_index{
-                    Ok(())
+                    None
                 }else{
                     self.handle_index(&arr.hir_id, &arr.kind, &index.kind)
                 }
             }
-            _ => Ok(()),
+            _ => None,
         }
     }
 
@@ -76,13 +72,13 @@ impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
         expr_id: &HirId,
         arr: &'a ExprKind<'a>,
         index: &'a ExprKind<'a>,
-    ) -> Result<(), ()> {
+    ) -> Option<()> {
         match arr {
             ExprKind::Field(_, _) | ExprKind::Path(_) => {
                 let type_name = self.get_id_type(expr_id)?;
                 self.final_check(&type_name, index)
             }
-            _ => Ok(()),
+            _ => Some(()),
         }
     }
 
@@ -90,21 +86,21 @@ impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
         &mut self,
         kind: &'a ExprKind<'a>,
         arguments: &'a [Expr<'a>],
-    ) -> Result<(), ()> {
+    ) -> Option<()> {
         match kind {
             ExprKind::Path(object_path) => {
                 if arguments.len() != 1 {
-                    return Ok(());
+                    return Some(());
                 }
                 let index = &arguments.first().unwrap().kind;
 
                 self.handle_path(object_path, index)
             }
-            _ => Ok(()),
+            _ => Some(()),
         }
     }
 
-    fn get_id_type(&mut self, id: &HirId) -> Result<String, ()> {
+    fn get_id_type(&mut self, id: &HirId) -> Option<String> {
         let object_type = get_node_type(self.cx, id);
         let kind = object_type.kind();
         let (def, _generic_args) = type_to_adt(kind)?;
@@ -116,40 +112,40 @@ impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
             .collect::<Vec<_>>()
             .join("::");
 
-        Ok(type_name)
+        Some(type_name)
     }
 
-    fn get_path_type(&mut self, object_path: &'_ QPath<'_>) -> Result<String, ()> {
+    fn get_path_type(&mut self, object_path: &'_ QPath<'_>) -> Option<String> {
         let (_, object_path) = path_to_resolved(object_path)?;
         let object_decl_hir_id = resolution_to_local(&object_path.res)?;
 
         self.get_id_type(object_decl_hir_id)
     }
 
-    fn get_expression_id(&mut self, expr: &'a ExprKind<'a>) -> Result<HirId, ()> {
+    fn get_expression_id(&mut self, expr: &'a ExprKind<'a>) -> Option<HirId> {
         let index_qpath = expr_to_path(expr)?;
         let (_, index_path) = path_to_resolved(&index_qpath)?;
-        Ok(*resolution_to_local(&index_path.res)?)
+        Some(*resolution_to_local(&index_path.res)?)
     }
 
     fn handle_path(
         &mut self,
         object_path: &'a QPath<'a>,
         index: &'a ExprKind<'a>,
-    ) -> Result<(), ()> {
+    ) -> Option<()> {
         let type_name = self.get_path_type(object_path)?;
         self.final_check(&type_name, index)
     }
 
-    fn final_check(&mut self, object_type: &String, index: &'a ExprKind<'a>) -> Result<(), ()> {
+    fn final_check(&mut self, object_type: &String, index: &'a ExprKind<'a>) -> Option<()> {
         if !self.config.relevant_object_types.contains(object_type) {
-            return Ok(());
+            return Some(());
         }
 
         if self.get_expression_id(index)? == self.index_id {
             self.has_vector_access = true;
         }
-        Ok(())
+        Some(())
     }
 }
 
@@ -162,169 +158,6 @@ impl<'a, 'b, 'c> Visitor<'a> for VectorAccessVisitor<'a, 'b, 'c> {
 
 //---------------------------------------------------------------------
 
-fn type_to_adt<'hir>(
-    kind: &'hir rustc_type_ir::TyKind<TyCtxt<'hir>>,
-) -> Result<
-    (
-        &'hir <TyCtxt<'hir> as Interner>::AdtDef,
-        &'hir <TyCtxt<'hir> as Interner>::GenericArgs,
-    ),
-    (),
-> {
-    if let TyKind::Adt(a, b) = kind {
-        Ok((a, b))
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn stmt_to_expr<'hir>(kind: &'hir StmtKind<'hir>) -> Result<&'hir Expr<'hir>, ()> {
-    if let StmtKind::Expr(a) = kind {
-        Ok(a)
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn expr_to_drop_temps<'hir>(kind: &'hir ExprKind<'hir>) -> Result<&'hir Expr<'hir>, ()> {
-    if let ExprKind::DropTemps(a) = kind {
-        Ok(a)
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_match<'hir>(
-    kind: &'hir ExprKind<'hir>,
-) -> Result<(&'hir Expr<'hir>, &'hir [rustc_hir::Arm<'hir>], MatchSource), ()> {
-    if let ExprKind::Match(a, b, c) = kind {
-        Ok((a, b, *c))
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_call<'hir>(
-    kind: &'hir ExprKind<'hir>,
-) -> Result<(&'hir Expr<'hir>, &'hir [Expr<'hir>]), ()> {
-    if let ExprKind::Call(a, b) = kind {
-        Ok((a, b))
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_path<'hir>(kind: &'hir ExprKind<'hir>) -> Result<QPath<'hir>, ()> {
-    if let ExprKind::Path(a) = kind {
-        Ok(*a)
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_struct<'hir>(
-    kind: &'hir ExprKind<'hir>,
-) -> Result<
-    (
-        &'hir QPath<'hir>,
-        &'hir [ExprField<'hir>],
-        Option<&'hir Expr<'hir>>,
-    ),
-    (),
-> {
-    if let ExprKind::Struct(a, b, c) = kind {
-        Ok((a, b, *c))
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_lit<'hir>(kind: &'hir ExprKind<'hir>) -> Result<&'hir rustc_hir::Lit, ()> {
-    if let ExprKind::Lit(a) = kind {
-        Ok(a)
-    } else {
-        Err(())
-    }
-}
-
-fn expr_to_loop<'hir>(
-    kind: &'hir ExprKind<'hir>,
-) -> Result<(&'hir Block<'hir>, &Option<Label>, LoopSource, &Span), ()> {
-    if let ExprKind::Loop(a, b, c, d) = kind {
-        Ok((a, b, *c, d))
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn path_to_lang_item(path: &QPath) -> Result<(LangItem, Span), ()> {
-    if let QPath::LangItem(a, b) = path {
-        Ok((*a, *b))
-    } else {
-        Err(())
-    }
-}
-
-fn path_to_resolved<'hir>(
-    path: &'hir QPath<'hir>,
-) -> Result<(&'hir Option<&'hir Ty<'hir>>, &'hir Path<'hir>), ()> {
-    if let QPath::Resolved(a, b) = path {
-        Ok((a, b))
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn resolution_to_local(resolution: &Res) -> Result<&HirId, ()> {
-    if let Res::Local(a) = resolution {
-        Ok(a)
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn lit_to_int(kind: &LitKind) -> Result<(u128, LitIntType), ()> {
-    if let LitKind::Int(a, b) = kind {
-        Ok((a.get(), *b))
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
-fn pattern_to_struct<'hir>(
-    pat: &'hir PatKind<'hir>,
-) -> Result<(&QPath<'hir>, &'hir [PatField<'hir>], bool), ()> {
-    if let PatKind::Struct(a, b, c) = pat {
-        Ok((a, b, *c))
-    } else {
-        Err(())
-    }
-}
-
-fn pattern_to_binding<'hir>(
-    pat: &'hir PatKind<'hir>,
-) -> Result<(&BindingMode, &HirId, &Ident, &Option<&'hir Pat<'hir>>), ()> {
-    if let PatKind::Binding(a, b, c, d) = pat {
-        Ok((a, b, c, d))
-    } else {
-        Err(())
-    }
-}
-
-//---------------------------------------------------------------------
-
 fn is_range(item: LangItem) -> bool {
     matches!(
         item,
@@ -334,47 +167,47 @@ fn is_range(item: LangItem) -> bool {
 
 //---------------------------------------------------------------------
 
-fn handle_expr<'a>(me: &mut ForLoopVisitor<'a, '_, '_>, expr: &'a Expr<'a>) -> Result<(), ()> {
+fn handle_expr<'a>(me: &mut ForLoopVisitor<'a, '_, '_>, expr: &'a Expr<'a>) -> Option<()> {
     //Ignore DropTemps()
-    let expr = expr_to_drop_temps(&expr.kind).or(Ok(expr))?;
+    let expr = expr_to_drop_temps(&expr.kind).or(Some(expr))?;
 
     let (match_expr, arms, source) = expr_to_match(&expr.kind)?;
     if source != MatchSource::ForLoopDesugar {
-        return Ok(());
+        return Some(());
     }
     let (func, args) = expr_to_call(&match_expr.kind)?;
     let qpath = expr_to_path(&func.kind)?;
     let (item, _) = path_to_lang_item(&qpath)?;
     if item != LangItem::IntoIterIntoIter {
-        return Ok(());
+        return Some(());
     }
     if args.first().is_none() {
-        return Ok(());
+        return Some(());
     }
     let (qpath, fields, _) = expr_to_struct(&args.first().unwrap().kind)?;
     let (langitem, _) = path_to_lang_item(qpath)?;
     if !is_range(langitem) {
-        return Ok(());
+        return Some(());
     }
     if fields.last().is_none() {
-        return Ok(());
+        return Some(());
     }
     let lit = expr_to_lit(&fields.last().unwrap().expr.kind)?;
     let _ = lit_to_int(&lit.node)?;
     if arms.first().is_none() {
-        return Ok(());
+        return Some(());
     }
     let (block, _, loopsource, _) = expr_to_loop(&arms.first().unwrap().body.kind)?;
     if loopsource != LoopSource::ForLoop {
-        return Ok(());
+        return Some(());
     }
     if block.stmts.first().is_none() {
-        return Ok(());
+        return Some(());
     }
     let stmtexpr = stmt_to_expr(&block.stmts.first().unwrap().kind)?;
     let (_, some_none_arms, match_source) = expr_to_match(&stmtexpr.kind)?;
     if match_source != MatchSource::ForLoopDesugar {
-        return Ok(());
+        return Some(());
     }
 
     let mut visitor = VectorAccessVisitor {
@@ -384,20 +217,20 @@ fn handle_expr<'a>(me: &mut ForLoopVisitor<'a, '_, '_>, expr: &'a Expr<'a>) -> R
         cx: me.cx,
     };
     for arm in some_none_arms {
-        let hir_id = (|| -> Result<HirId, ()> {
+        let hir_id = (|| -> Option<HirId> {
             let (qpath, pats, _) = pattern_to_struct(&arm.pat.kind)?;
             let (item_type, _) = path_to_lang_item(qpath)?;
             if item_type != LangItem::OptionSome {
-                return Err(());
+                return None;
             }
             if pats.last().is_none() {
-                return Err(());
+                return None;
             }
             let (_, hir_id, _ident, _) = pattern_to_binding(&pats.last().unwrap().pat.kind)?;
-            Ok(*hir_id)
+            Some(*hir_id)
         })();
 
-        if let Ok(hir_id) = hir_id {
+        if let Some(hir_id) = hir_id {
             visitor.index_id = hir_id;
             walk_expr(&mut visitor, arm.body);
         }
@@ -407,7 +240,7 @@ fn handle_expr<'a>(me: &mut ForLoopVisitor<'a, '_, '_>, expr: &'a Expr<'a>) -> R
         me.span_constant.insert(expr.span);
     }
 
-    Ok(())
+    Some(())
 }
 
 impl<'a, 'b, 'c> Visitor<'a> for ForLoopVisitor<'a, 'b, 'c> {

From 8f6ad2050062c97f192e350a0ddc40424437c496 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 4 Dec 2024 11:44:50 -0300
Subject: [PATCH 08/30] Use fully qualified path

---
 .../unsigned-extrinsic/src/lib.rs               | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
index 411c3bc9..3ade5681 100644
--- a/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
+++ b/detectors/substrate-pallets/unsigned-extrinsic/src/lib.rs
@@ -12,15 +12,17 @@ use common::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
+    def::Res,
     def_id::LocalDefId,
     intravisit::{walk_expr, FnKind, Visitor},
     Body, Expr, ExprKind, FnDecl, QPath,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 
 const LINT_MESSAGE: &str =
     "Using unsigned extrinsics without fees exposes the chain to potential DoS attacks";
+const ENSURE_NONE_PATH: &str = "frame_system::ensure_none";
 
 #[expose_lint_info]
 pub static UNSIGNED_EXTRINSIC_INFO: LintInfo = LintInfo {
@@ -49,22 +51,21 @@ struct UnsignedExtrinsicVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for UnsignedExtrinsicVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         if_chain! {
-            // Ignore expressions from proc macros
             if !is_from_proc_macro(self.cx, expr);
-            // Check if the expression is `ensure_none`
-            if let ExprKind::Call(callee, args) = &expr.kind;
+            // Find `ensure_none` calls
+            if let ExprKind::Call(callee, [origin, ..]) = &expr.kind;
             if let ExprKind::Path(QPath::Resolved(None, path)) = &callee.kind;
-            if let Some(last_segment) = path.segments.last();
-            if last_segment.ident.name == Symbol::intern("ensure_none");
+            if let Some(segment) = path.segments.last();
+            if let Res::Def(_, def_id) = segment.res;
+            if self.cx.tcx.def_path_str(def_id).contains(ENSURE_NONE_PATH);
             then {
-                let first_arg_str = snippet(self.cx, args[0].span, "..");
                 span_lint_and_sugg(
                     self.cx,
                     UNSIGNED_EXTRINSIC,
                     expr.span,
                     LINT_MESSAGE,
                     "consider signing this extrinsic to prevent DoS attacks",
-                    format!("ensure_signed({})", first_arg_str),
+                    format!("ensure_signed({})", snippet(self.cx, origin.span, "..")),
                     Applicability::MaybeIncorrect,
                 );
             }

From 214c4cd17f02420b1421ec329161dba653bb4014 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 4 Dec 2024 11:53:46 -0300
Subject: [PATCH 09/30] Remove unwanted line

---
 .../assert-violation/vulnerable/vulnerable-1/src/lib.rs          | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
index 5e6ff5b3..084c695a 100644
--- a/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1/src/lib.rs
@@ -39,7 +39,6 @@ pub mod pallet {
         #[pallet::call_index(0)]
         pub fn unsafe_check_balance(origin: OriginFor<T>, amount: u32) -> DispatchResult {
             let who = ensure_signed(origin)?;
-            ensure_none(who);
             assert!(
                 BalanceStorage::<T>::get().unwrap_or(0) >= amount,
                 "Insufficient balance"

From 52ac0fc411349cf7f4099cff25101996674d6696 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 4 Dec 2024 15:52:43 -0300
Subject: [PATCH 10/30] Add test-cases and detector

---
 detectors/substrate-pallets/Cargo.lock        |  10 ++
 .../invalid-extrinsic-weight/Cargo.toml       |  16 +++
 .../invalid-extrinsic-weight/src/lib.rs       | 119 ++++++++++++++++++
 test-cases/substrate-pallets/Cargo.lock       |  30 +++++
 .../remediated/remediated-1/Cargo.toml        |  34 +++++
 .../remediated/remediated-1/src/lib.rs        |  52 ++++++++
 .../remediated/remediated-1/src/weights.rs    |  32 +++++
 .../vulnerable/vulnerable-1/Cargo.toml        |  34 +++++
 .../vulnerable/vulnerable-1/src/lib.rs        |  53 ++++++++
 .../vulnerable/vulnerable-1/src/weights.rs    |  26 ++++
 10 files changed, 406 insertions(+)
 create mode 100644 detectors/substrate-pallets/invalid-extrinsic-weight/Cargo.toml
 create mode 100644 detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/weights.rs

diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index b98c6ba7..fbd73fd9 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -1639,6 +1639,16 @@ dependencies = [
  "if_chain",
 ]
 
+[[package]]
+name = "invalid-extrinsic-weight"
+version = "0.1.0"
+dependencies = [
+ "clippy_utils",
+ "common",
+ "dylint_linting",
+ "if_chain",
+]
+
 [[package]]
 name = "io-close"
 version = "0.3.7"
diff --git a/detectors/substrate-pallets/invalid-extrinsic-weight/Cargo.toml b/detectors/substrate-pallets/invalid-extrinsic-weight/Cargo.toml
new file mode 100644
index 00000000..f2054d46
--- /dev/null
+++ b/detectors/substrate-pallets/invalid-extrinsic-weight/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+edition = "2021"
+name = "invalid-extrinsic-weight"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+clippy_utils = { workspace = true }
+common = { workspace = true }
+dylint_linting = { workspace = true }
+if_chain = { workspace = true }
+
+[package.metadata.rust-analyzer]
+rustc_private = true
diff --git a/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs b/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
new file mode 100644
index 00000000..abc2f1db
--- /dev/null
+++ b/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
@@ -0,0 +1,119 @@
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+
+use clippy_utils::diagnostics::span_lint_and_help;
+use common::{
+    declarations::{Severity, VulnerabilityClass},
+    macros::expose_lint_info,
+};
+use rustc_ast::{
+    token::TokenKind, tokenstream::TokenTree, AssocItemKind, HasTokens, Item, ItemKind,
+};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+
+const LINT_MESSAGE: &str =
+    "Invalid weight attribute: Each extrinsic must use its own unique weight calculation function.";
+
+#[expose_lint_info]
+pub static INVALID_EXTRINSIC_WEIGHT_INFO: LintInfo = LintInfo {
+    name: env!("CARGO_PKG_NAME"),
+    short_message: LINT_MESSAGE,
+    long_message: "The weight attribute is using a weight calculation function that doesn't match the extrinsic name. \
+                    Each extrinsic must have its own dedicated weight calculation to accurately reflect its resource consumption. \
+                    Reusing weight calculations from other functions can lead to incorrect resource estimation and potential issues in production.",
+    severity: Severity::Enhancement,
+    help: "https://coinfabrik.github.io/scout/docs/vulnerabilities/invalid-weight-info",
+    vulnerability_class: VulnerabilityClass::KnownBugs,
+};
+
+dylint_linting::declare_pre_expansion_lint! {
+    pub INVALID_EXTRINSIC_WEIGHT,
+    Warn,
+    LINT_MESSAGE
+}
+
+struct WeightInfoValidator {
+    function_name: String,
+    collected_text: Vec<String>,
+}
+
+impl WeightInfoValidator {
+    fn new(function_name: String) -> Self {
+        Self {
+            function_name,
+            collected_text: Vec::new(),
+        }
+    }
+
+    fn process_token_trees(&mut self, trees: &[TokenTree]) {
+        for tree in trees {
+            match tree {
+                TokenTree::Delimited(.., token_stream) => {
+                    self.process_token_trees(&token_stream.trees().cloned().collect::<Vec<_>>());
+                }
+                TokenTree::Token(token, _) => {
+                    if let TokenKind::Ident(symbol, _) = token.kind {
+                        self.collected_text.push(symbol.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    fn is_valid_weight_info(&self) -> bool {
+        // Less than 4 elements means we are not in the weight attribute
+        if self.collected_text.len() < 4 {
+            return true;
+        }
+
+        // We are looking for the following pattern: #[pallet::weight(...::WeightInfo::FUNCTION_NAME)]
+        // First two items should be "pallet" and "weight"
+        let is_pallet_attr = self.collected_text[0] == "pallet";
+        let is_weight_attr = self.collected_text[1] == "weight";
+
+        // Last item should be the function name
+        let function_name = &self.collected_text[self.collected_text.len() - 1];
+        let is_function_attr = function_name == &self.function_name;
+
+        // Second to last should be "WeightInfo"
+        let second_last = &self.collected_text[self.collected_text.len() - 2];
+        let is_weight_info = second_last == "WeightInfo";
+
+        is_pallet_attr && is_weight_attr && is_function_attr && is_weight_info
+    }
+}
+
+impl EarlyLintPass for InvalidExtrinsicWeight {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::Impl(impl_) = &item.kind {
+            for impl_item in &impl_.items {
+                if let AssocItemKind::Fn(..) = &impl_item.kind {
+                    let fn_name = impl_item.ident.name.to_string();
+
+                    for attr in &impl_item.attrs {
+                        if let Some(token_stream) = attr.tokens() {
+                            let mut validator = WeightInfoValidator::new(fn_name.clone());
+
+                            let attr_token_stream = token_stream.to_attr_token_stream();
+                            let attr_token_trees = attr_token_stream.to_token_trees();
+
+                            validator.process_token_trees(&attr_token_trees);
+
+                            if !validator.is_valid_weight_info() {
+                                span_lint_and_help(
+                                    cx,
+                                    INVALID_EXTRINSIC_WEIGHT,
+                                    impl_item.span,
+                                    LINT_MESSAGE,
+                                    Some(attr.span),
+                                    "used here",
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 4e05a56d..150d2bb0 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -1496,6 +1496,36 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "invalid-extrinsic-weight-remediated-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "invalid-extrinsic-weight-vulnerable-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "itertools"
 version = "0.10.5"
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/Cargo.toml b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/Cargo.toml
new file mode 100644
index 00000000..4531c49f
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "invalid-extrinsic-weight-remediated-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/lib.rs
new file mode 100644
index 00000000..3bec0841
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/lib.rs
@@ -0,0 +1,52 @@
+// lib.rs
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        /// Weight information for extrinsics in this pallet.
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn example_storage)]
+    pub type ExampleStorage<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        // Add on_initialize if we need any per-block logic
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn dummy_call(_origin: OriginFor<T>) -> DispatchResult {
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        pub fn another_dummy_call(_origin: OriginFor<T>) -> DispatchResult {
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    pub enum Event<T: Config> {}
+}
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/weights.rs b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/weights.rs
new file mode 100644
index 00000000..dc2423f1
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/remediated/remediated-1/src/weights.rs
@@ -0,0 +1,32 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn dummy_call() -> Weight;
+	fn another_dummy_call() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	fn another_dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+	}
+}
+
+impl WeightInfo for () {
+	fn dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	fn another_dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+	}
+}
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/Cargo.toml
new file mode 100644
index 00000000..13b3b5d4
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "invalid-extrinsic-weight-vulnerable-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/lib.rs
new file mode 100644
index 00000000..c501e4bd
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/lib.rs
@@ -0,0 +1,53 @@
+// lib.rs
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        /// Weight information for extrinsics in this pallet.
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn example_storage)]
+    pub type ExampleStorage<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        // Add on_initialize if we need any per-block logic
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn dummy_call(_origin: OriginFor<T>) -> DispatchResult {
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(<T as Config>::WeightInfo::dummy_call())]
+        pub fn another_dummy_call(_origin: OriginFor<T>) -> DispatchResult {
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    pub enum Event<T: Config> {}
+}
diff --git a/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/weights.rs b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/weights.rs
new file mode 100644
index 00000000..207db2f2
--- /dev/null
+++ b/test-cases/substrate-pallets/invalid-extrinsic-weight/vulnerable/vulnerable-1/src/weights.rs
@@ -0,0 +1,26 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn dummy_call() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+
+}
+
+impl WeightInfo for () {
+	fn dummy_call() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+}

From ca36d563c8d03c3b767c5badd370071edc0f7085 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 4 Dec 2024 16:06:05 -0300
Subject: [PATCH 11/30] Fix attr panic on `.tokens()`

---
 .../substrate-pallets/invalid-extrinsic-weight/src/lib.rs     | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs b/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
index abc2f1db..aa9d6206 100644
--- a/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
+++ b/detectors/substrate-pallets/invalid-extrinsic-weight/src/lib.rs
@@ -92,6 +92,10 @@ impl EarlyLintPass for InvalidExtrinsicWeight {
                     let fn_name = impl_item.ident.name.to_string();
 
                     for attr in &impl_item.attrs {
+                        if attr.is_doc_comment() {
+                            continue;
+                        }
+
                         if let Some(token_stream) = attr.tokens() {
                             let mut validator = WeightInfoValidator::new(fn_name.clone());
 

From 3ac59464569c20db212c76a53932932263ec96d1 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 5 Dec 2024 14:26:22 -0300
Subject: [PATCH 12/30] Delete soroban detector and add small modification to
 rust detector

---
 .../rust/incorrect-exponentiation/src/lib.rs  | 39 ++++----
 detectors/soroban/Cargo.lock                  | 11 ---
 .../incorrect-exponentiation/Cargo.toml       | 17 ----
 .../incorrect-exponentiation/src/lib.rs       | 94 -------------------
 4 files changed, 19 insertions(+), 142 deletions(-)
 delete mode 100644 detectors/soroban/incorrect-exponentiation/Cargo.toml
 delete mode 100644 detectors/soroban/incorrect-exponentiation/src/lib.rs

diff --git a/detectors/rust/incorrect-exponentiation/src/lib.rs b/detectors/rust/incorrect-exponentiation/src/lib.rs
index 46eea06d..bf8f424c 100644
--- a/detectors/rust/incorrect-exponentiation/src/lib.rs
+++ b/detectors/rust/incorrect-exponentiation/src/lib.rs
@@ -45,16 +45,20 @@ impl<'tcx> LateLintPass<'tcx> for IncorrectExponentiation {
         _: Span,
         _: LocalDefId,
     ) {
-        struct IncorrectExponentiationStorage {
+        struct IncorrectExponentiationVisitor {
             span: Vec<Span>,
-            incorrect_exponentiation: bool,
         }
 
-        impl<'tcx> Visitor<'tcx> for IncorrectExponentiationStorage {
+        impl<'tcx> Visitor<'tcx> for IncorrectExponentiationVisitor {
             fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+                if let ExprKind::AssignOp(binop, _, _) = &expr.kind {
+                    if binop.node == rustc_hir::BinOpKind::BitXor {
+                        self.span.push(expr.span);
+                    }
+                }
+
                 if let ExprKind::Binary(op, _, _) = &expr.kind {
                     if op.node == rustc_hir::BinOpKind::BitXor {
-                        self.incorrect_exponentiation = true;
                         self.span.push(expr.span);
                     }
                 }
@@ -63,24 +67,19 @@ impl<'tcx> LateLintPass<'tcx> for IncorrectExponentiation {
             }
         }
 
-        let mut expon_storage = IncorrectExponentiationStorage {
-            span: Vec::new(),
-            incorrect_exponentiation: false,
-        };
+        let mut exponentiation_visitor = IncorrectExponentiationVisitor { span: Vec::new() };
 
-        walk_expr(&mut expon_storage, body.value);
+        walk_expr(&mut exponentiation_visitor, body.value);
 
-        if expon_storage.incorrect_exponentiation {
-            for span in expon_storage.span.iter() {
-                span_lint_and_help(
-                    cx,
-                    INCORRECT_EXPONENTIATION,
-                    *span,
-                    LINT_MESSAGE,
-                    None,
-                    LINT_HELP,
-                );
-            }
+        for span in exponentiation_visitor.span.iter() {
+            span_lint_and_help(
+                cx,
+                INCORRECT_EXPONENTIATION,
+                *span,
+                LINT_MESSAGE,
+                None,
+                LINT_HELP,
+            );
         }
     }
 }
diff --git a/detectors/soroban/Cargo.lock b/detectors/soroban/Cargo.lock
index b87882e8..f03773f1 100644
--- a/detectors/soroban/Cargo.lock
+++ b/detectors/soroban/Cargo.lock
@@ -439,17 +439,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
 
-[[package]]
-name = "incorrect-exponentiation"
-version = "0.1.0"
-dependencies = [
- "clippy_utils",
- "common",
- "dylint_internal",
- "dylint_linting",
- "if_chain",
-]
-
 [[package]]
 name = "indexmap"
 version = "2.6.0"
diff --git a/detectors/soroban/incorrect-exponentiation/Cargo.toml b/detectors/soroban/incorrect-exponentiation/Cargo.toml
deleted file mode 100644
index 1fe81fed..00000000
--- a/detectors/soroban/incorrect-exponentiation/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-edition = "2021"
-name = "incorrect-exponentiation"
-version = "0.1.0"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-clippy_utils = { workspace = true }
-common = { workspace = true }
-dylint_internal = { workspace = true }
-dylint_linting = { workspace = true }
-if_chain = { workspace = true }
-
-[package.metadata.rust-analyzer]
-rustc_private = true
diff --git a/detectors/soroban/incorrect-exponentiation/src/lib.rs b/detectors/soroban/incorrect-exponentiation/src/lib.rs
deleted file mode 100644
index 79747501..00000000
--- a/detectors/soroban/incorrect-exponentiation/src/lib.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-#![feature(rustc_private)]
-#![warn(unused_extern_crates)]
-
-extern crate rustc_hir;
-extern crate rustc_span;
-
-use clippy_utils::diagnostics::span_lint_and_help;
-use common::{
-    declarations::{Severity, VulnerabilityClass},
-    macros::expose_lint_info,
-};
-use rustc_hir::def_id::LocalDefId;
-use rustc_hir::intravisit::Visitor;
-use rustc_hir::intravisit::{walk_expr, FnKind};
-use rustc_hir::{Body, FnDecl};
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::Span;
-
-const LINT_MESSAGE: &str = "'^' It is not an exponential operator. It is a bitwise XOR.";
-const LINT_HELP: &str = "If you want to use XOR, use bitxor(). If you want to raise a number use .checked_pow() or .pow() ";
-
-#[expose_lint_info]
-pub static INCORRECT_EXPONENTIATION_INFO: LintInfo = LintInfo {
-    name: env!("CARGO_PKG_NAME"),
-    short_message: LINT_MESSAGE,
-    long_message: LINT_MESSAGE,
-    severity: Severity::Critical,
-    help: LINT_HELP,
-    vulnerability_class: VulnerabilityClass::Arithmetic,
-};
-
-dylint_linting::declare_late_lint! {
-    pub INCORRECT_EXPONENTIATION,
-    Warn,
-    LINT_MESSAGE
-}
-
-impl<'tcx> LateLintPass<'tcx> for IncorrectExponentiation {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        _: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
-        _: Span,
-        _: LocalDefId,
-    ) {
-        struct IncorrectExponentiationStorage {
-            span: Vec<Span>,
-            incorrect_exponentiation: bool,
-        }
-
-        impl<'tcx> Visitor<'tcx> for IncorrectExponentiationStorage {
-            fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-                if let ExprKind::AssignOp(binop, _, _) = &expr.kind {
-                    if binop.node == rustc_hir::BinOpKind::BitXor {
-                        self.incorrect_exponentiation = true;
-                        self.span.push(expr.span);
-                    }
-                }
-
-                if let ExprKind::Binary(op, _, _) = &expr.kind {
-                    if op.node == rustc_hir::BinOpKind::BitXor {
-                        self.incorrect_exponentiation = true;
-                        self.span.push(expr.span);
-                    }
-                }
-
-                walk_expr(self, expr);
-            }
-        }
-
-        let mut expon_storage = IncorrectExponentiationStorage {
-            span: Vec::new(),
-            incorrect_exponentiation: false,
-        };
-
-        walk_expr(&mut expon_storage, body.value);
-
-        if expon_storage.incorrect_exponentiation {
-            for span in expon_storage.span.iter() {
-                span_lint_and_help(
-                    cx,
-                    INCORRECT_EXPONENTIATION,
-                    *span,
-                    LINT_MESSAGE,
-                    None,
-                    LINT_HELP,
-                );
-            }
-        }
-    }
-}

From fed4141018b2f9ebe2cd564fd4ba49426585c6cb Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 5 Dec 2024 15:48:29 -0300
Subject: [PATCH 13/30] Unify detectors, unify common. Remove unused stuff

---
 common/detectors/src/lib.rs                   |   2 +-
 .../{unsafe_expect.rs => unsafe_checks.rs}    | 134 ++++---
 detectors/ink/Cargo.lock                      |  11 -
 detectors/ink/unsafe-unwrap/src/lib.rs        | 341 ------------------
 detectors/rust/unsafe-expect/src/lib.rs       |   4 +-
 .../{ink => rust}/unsafe-unwrap/Cargo.toml    |   2 +-
 detectors/rust/unsafe-unwrap/src/lib.rs       |  64 ++++
 detectors/soroban/Cargo.lock                  |  11 -
 detectors/soroban/unsafe-unwrap/Cargo.toml    |  18 -
 detectors/soroban/unsafe-unwrap/src/lib.rs    | 340 -----------------
 detectors/substrate-pallets/Cargo.lock        |   2 +-
 .../unsafe-expect/src/lib.rs                  |   6 +-
 .../unsafe-unwrap/Cargo.toml                  |   2 +-
 .../unsafe-unwrap/src/lib.rs                  | 301 +---------------
 14 files changed, 169 insertions(+), 1069 deletions(-)
 rename common/detectors/src/{unsafe_expect.rs => unsafe_checks.rs} (76%)
 delete mode 100644 detectors/ink/unsafe-unwrap/src/lib.rs
 rename detectors/{ink => rust}/unsafe-unwrap/Cargo.toml (88%)
 create mode 100644 detectors/rust/unsafe-unwrap/src/lib.rs
 delete mode 100644 detectors/soroban/unsafe-unwrap/Cargo.toml
 delete mode 100644 detectors/soroban/unsafe-unwrap/src/lib.rs

diff --git a/common/detectors/src/lib.rs b/common/detectors/src/lib.rs
index 24ceae10..9c3f4c57 100644
--- a/common/detectors/src/lib.rs
+++ b/common/detectors/src/lib.rs
@@ -2,4 +2,4 @@
 #![feature(let_chains)]
 
 pub mod iterators_over_indexing;
-pub mod unsafe_expect;
+pub mod unsafe_checks;
diff --git a/common/detectors/src/unsafe_expect.rs b/common/detectors/src/unsafe_checks.rs
similarity index 76%
rename from common/detectors/src/unsafe_expect.rs
rename to common/detectors/src/unsafe_checks.rs
index 2ad6bf66..d69f58c5 100644
--- a/common/detectors/src/unsafe_expect.rs
+++ b/common/detectors/src/unsafe_checks.rs
@@ -1,10 +1,8 @@
-#![allow(clippy::enum_variant_names)]
-
 extern crate rustc_hir;
 extern crate rustc_lint;
 extern crate rustc_span;
 
-use analysis::ConstantAnalyzer;
+use analysis::{get_node_type_opt, match_type_to_str, ConstantAnalyzer};
 use clippy_utils::{diagnostics::span_lint_and_help, higher::IfOrIfLet, is_from_proc_macro};
 use if_chain::if_chain;
 use rustc_hir::{
@@ -20,7 +18,7 @@ const PANIC_INDUCING_FUNCTIONS: [&str; 2] = ["panic", "bail"];
 
 /// Represents the type of check performed on method call expressions to determine their safety or behavior.
 #[derive(Clone, Copy, Hash, Eq, PartialEq)]
-enum CheckType {
+pub enum CheckType {
     IsSome,
     IsNone,
     IsOk,
@@ -52,8 +50,8 @@ impl CheckType {
         matches!(self, Self::IsNone | Self::IsErr)
     }
 
-    /// Determines if it is safe to expect the value without further checks, i.e., the value is present.
-    fn is_safe_to_expect(self) -> bool {
+    /// Determines if it is safe to unwrap the value without further checks, i.e., the value is present.
+    fn is_safe(self) -> bool {
         matches!(self, Self::IsSome | Self::IsOk)
     }
 }
@@ -98,27 +96,39 @@ impl ConditionalChecker {
     }
 }
 
-/// Main unsafe-expect visitor
-pub struct UnsafeExpectVisitor<'a, 'tcx> {
+// Enum to represent the type being unwrapped
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum UnwrapType {
+    Option,
+    Result,
+}
+
+pub struct UnsafeChecks<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     lint: &'static Lint,
     constant_analyzer: ConstantAnalyzer<'a, 'tcx>,
     conditional_checker: HashSet<ConditionalChecker>,
     checked_exprs: HashSet<HirId>,
+    returns_result_or_option: bool,
+    // Only sym::expect or sym::unwrap are supported, DO NOT USE OTHER SYMBOLS
+    checks_symbol: Symbol,
 }
 
-impl<'a, 'tcx> UnsafeExpectVisitor<'a, 'tcx> {
+impl<'a, 'tcx> UnsafeChecks<'a, 'tcx> {
     pub fn new(
         cx: &'a LateContext<'tcx>,
         lint: &'static Lint,
         constant_analyzer: ConstantAnalyzer<'a, 'tcx>,
+        checks_symbol: Symbol,
     ) -> Self {
         Self {
             cx,
             lint,
+            checks_symbol,
             constant_analyzer,
             conditional_checker: HashSet::new(),
             checked_exprs: HashSet::new(),
+            returns_result_or_option: false,
         }
     }
 
@@ -133,17 +143,6 @@ impl<'a, 'tcx> UnsafeExpectVisitor<'a, 'tcx> {
         false
     }
 
-    fn get_expect_info(&self, receiver: &Expr<'tcx>) -> Option<HirId> {
-        if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &receiver.kind;
-            if let Res::Local(hir_id) = path.res;
-            then {
-                return Some(hir_id);
-            }
-        }
-        None
-    }
-
     fn update_conditional_checker(
         &mut self,
         conditional_checkers: &HashSet<ConditionalChecker>,
@@ -152,11 +151,11 @@ impl<'a, 'tcx> UnsafeExpectVisitor<'a, 'tcx> {
         for checker in conditional_checkers {
             if set {
                 self.conditional_checker.insert(*checker);
-                if checker.check_type.is_safe_to_expect() {
+                if checker.check_type.is_safe() {
                     self.checked_exprs.insert(checker.checked_expr_hir_id);
                 }
             } else {
-                if checker.check_type.is_safe_to_expect() {
+                if checker.check_type.is_safe() {
                     self.checked_exprs.remove(&checker.checked_expr_hir_id);
                 }
                 self.conditional_checker.remove(checker);
@@ -164,45 +163,37 @@ impl<'a, 'tcx> UnsafeExpectVisitor<'a, 'tcx> {
         }
     }
 
-    /// Process conditional expressions to determine if they should halt execution.
-    fn handle_if_expressions(&mut self) {
-        self.conditional_checker.iter().for_each(|checker| {
-            if checker.check_type.should_halt_execution() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
+    fn get_check_info(&self, receiver: &Expr<'tcx>) -> Option<HirId> {
+        if_chain! {
+            if let ExprKind::Path(QPath::Resolved(_, path)) = &receiver.kind;
+            if let Res::Local(hir_id) = path.res;
+            then {
+                return Some(hir_id);
             }
-        });
+        }
+        None
     }
 
     fn is_method_call_unsafe(&self, path_segment: &PathSegment, receiver: &Expr<'tcx>) -> bool {
-        if path_segment.ident.name == sym::expect {
+        if path_segment.ident.name == self.checks_symbol {
             if self.constant_analyzer.is_constant(receiver) {
                 return false;
             }
 
             return self
-                .get_expect_info(receiver)
+                .get_check_info(receiver)
                 .map_or(true, |id| !self.checked_exprs.contains(&id));
         }
         false
     }
 
-    fn check_expr_for_unsafe_expect(&mut self, expr: &Expr<'tcx>) {
-        if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind {
-            if self.is_method_call_unsafe(path_segment, receiver) {
-                if is_from_proc_macro(self.cx, expr) {
-                    return;
-                }
-
-                span_lint_and_help(
-                    self.cx,
-                    self.lint,
-                    expr.span,
-                    self.lint.desc,
-                    None,
-                    "Please, use a custom error instead of `expect`",
-                );
+    /// Process conditional expressions to determine if they should halt execution.
+    fn handle_if_expressions(&mut self) {
+        self.conditional_checker.iter().for_each(|checker| {
+            if checker.check_type.should_halt_execution() {
+                self.checked_exprs.insert(checker.checked_expr_hir_id);
             }
-        }
+        });
     }
 
     fn check_for_try(&mut self, expr: &Expr<'tcx>) {
@@ -220,9 +211,56 @@ impl<'a, 'tcx> UnsafeExpectVisitor<'a, 'tcx> {
             }
         }
     }
+
+    fn check_expr_for_unsafe_method(&mut self, expr: &Expr<'tcx>) {
+        if_chain! {
+            if !is_from_proc_macro(self.cx, expr);
+            if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind;
+            if self.is_method_call_unsafe(path_segment, receiver);
+            then {
+                let help_message = if self.checks_symbol == sym::expect {
+                    "Please, use a custom error instead of `expect`"
+                } else {
+                    self.get_help_message(self.determine_unwrap_type(receiver))
+                };
+
+                span_lint_and_help(
+                    self.cx,
+                    self.lint,
+                    expr.span,
+                    self.lint.desc,
+                    None,
+                    help_message,
+                );
+            }
+        }
+    }
+
+    fn determine_unwrap_type(&self, receiver: &Expr<'tcx>) -> UnwrapType {
+        let type_opt = get_node_type_opt(self.cx, &receiver.hir_id);
+        if let Some(type_) = type_opt {
+            if match_type_to_str(self.cx, type_, "Result") {
+                return UnwrapType::Result;
+            }
+        }
+        UnwrapType::Option
+    }
+
+    fn get_help_message(&self, unwrap_type: UnwrapType) -> &'static str {
+        match (self.returns_result_or_option, unwrap_type) {
+            (true, UnwrapType::Option) => "Consider using `ok_or` to convert Option to Result",
+            (true, UnwrapType::Result) => "Consider using the `?` operator for error propagation",
+            (false, UnwrapType::Option) => {
+                "Consider pattern matching or using `if let` instead of `unwrap`"
+            }
+            (false, UnwrapType::Result) => {
+                "Consider handling the error case explicitly or using `if let` instead of `unwrap`"
+            }
+        }
+    }
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for UnsafeExpectVisitor<'a, 'tcx> {
+impl<'a, 'tcx> Visitor<'tcx> for UnsafeChecks<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         // Check for try desugaring '?'
         self.check_for_try(expr);
@@ -254,7 +292,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafeExpectVisitor<'a, 'tcx> {
         }
 
         // If we find an unsafe `expect`, we raise a warning
-        self.check_expr_for_unsafe_expect(expr);
+        self.check_expr_for_unsafe_method(expr);
 
         walk_expr(self, expr);
     }
diff --git a/detectors/ink/Cargo.lock b/detectors/ink/Cargo.lock
index 04277605..7a330c5e 100644
--- a/detectors/ink/Cargo.lock
+++ b/detectors/ink/Cargo.lock
@@ -1039,17 +1039,6 @@ dependencies = [
  "if_chain",
 ]
 
-[[package]]
-name = "unsafe-unwrap"
-version = "0.1.0"
-dependencies = [
- "clippy_utils",
- "common",
- "dylint_internal",
- "dylint_linting",
- "if_chain",
-]
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
diff --git a/detectors/ink/unsafe-unwrap/src/lib.rs b/detectors/ink/unsafe-unwrap/src/lib.rs
deleted file mode 100644
index 3312aba2..00000000
--- a/detectors/ink/unsafe-unwrap/src/lib.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-#![feature(rustc_private)]
-#![allow(clippy::enum_variant_names)]
-
-extern crate rustc_hir;
-extern crate rustc_span;
-
-use std::{collections::HashSet, hash::Hash};
-
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::higher;
-use common::{
-    declarations::{Severity, VulnerabilityClass},
-    macros::expose_lint_info,
-};
-use if_chain::if_chain;
-use rustc_hir::{
-    def::Res,
-    def_id::LocalDefId,
-    intravisit::{walk_expr, FnKind, Visitor},
-    BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, LetStmt, PathSegment, QPath, UnOp,
-};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{sym, Span, Symbol};
-
-const LINT_MESSAGE: &str = "Unsafe usage of `unwrap`";
-const PANIC_INDUCING_FUNCTIONS: [&str; 2] = ["panic", "bail"];
-
-#[expose_lint_info]
-pub static UNSAFE_UNWRAP_INFO: LintInfo = LintInfo {
-    name: env!("CARGO_PKG_NAME"),
-    short_message: LINT_MESSAGE,
-    long_message: "This vulnerability class pertains to the inappropriate usage of the unwrap method in Rust, which is commonly employed for error handling. The unwrap method retrieves the inner value of an Option or Result, but if an error or None occurs, it triggers a panic and crashes the program.    ",
-    severity: Severity::Medium,
-    help: "https://coinfabrik.github.io/scout/docs/vulnerabilities/unsafe-unwrap",
-    vulnerability_class: VulnerabilityClass::ErrorHandling,
-};
-
-dylint_linting::declare_late_lint! {
-    pub UNSAFE_UNWRAP,
-    Warn,
-    LINT_MESSAGE
-}
-
-/// Represents the type of check performed on method call expressions to determine their safety or behavior.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-enum CheckType {
-    IsSome,
-    IsNone,
-    IsOk,
-    IsErr,
-}
-
-impl CheckType {
-    fn from_method_name(name: Symbol) -> Option<Self> {
-        match name.as_str() {
-            "is_some" => Some(Self::IsSome),
-            "is_none" => Some(Self::IsNone),
-            "is_ok" => Some(Self::IsOk),
-            "is_err" => Some(Self::IsErr),
-            _ => None,
-        }
-    }
-
-    fn inverse(self) -> Self {
-        match self {
-            Self::IsSome => Self::IsNone,
-            Self::IsNone => Self::IsSome,
-            Self::IsOk => Self::IsErr,
-            Self::IsErr => Self::IsOk,
-        }
-    }
-
-    /// Determines if the check type implies execution should halt, such as in error conditions.
-    fn should_halt_execution(self) -> bool {
-        matches!(self, Self::IsNone | Self::IsErr)
-    }
-
-    /// Determines if it is safe to unwrap the value without further checks, i.e., the value is present.
-    fn is_safe_to_unwrap(self) -> bool {
-        matches!(self, Self::IsSome | Self::IsOk)
-    }
-}
-
-/// Represents a conditional checker that is used to analyze `if` or `if let` expressions.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-struct ConditionalChecker {
-    check_type: CheckType,
-    checked_expr_hir_id: HirId,
-}
-
-impl ConditionalChecker {
-    /// Handle te condition of the `if` or `if let` expression.
-    fn handle_condition(condition: &Expr<'_>, inverse: bool) -> HashSet<Self> {
-        if_chain! {
-            if let ExprKind::MethodCall(path_segment, receiver, _, _) = condition.kind;
-            if let Some(check_type) = CheckType::from_method_name(path_segment.ident.name);
-            if let ExprKind::Path(QPath::Resolved(_, checked_expr_path)) = receiver.kind;
-            if let Res::Local(checked_expr_hir_id) = checked_expr_path.res;
-            then {
-                let check_type = if inverse { check_type.inverse() } else { check_type };
-                return std::iter::once(Self { check_type, checked_expr_hir_id }).collect();
-            }
-        }
-        HashSet::new()
-    }
-
-    /// Constructs a ConditionalChecker from an expression if it matches a method call with a valid CheckType.
-    fn from_expression(condition: &Expr<'_>) -> HashSet<Self> {
-        match condition.kind {
-            // Single `not` expressions are supported
-            ExprKind::Unary(op, condition) => Self::handle_condition(condition, op == UnOp::Not),
-            // Multiple `or` expressions are supported
-            ExprKind::Binary(op, left_condition, right_condition) if op.node == BinOpKind::Or => {
-                let mut result = Self::from_expression(left_condition);
-                result.extend(Self::from_expression(right_condition));
-                result
-            }
-            ExprKind::MethodCall(..) => Self::handle_condition(condition, false),
-            _ => HashSet::new(),
-        }
-    }
-}
-
-/// Main unsafe-unwrap visitor
-struct UnsafeUnwrapVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    conditional_checker: HashSet<ConditionalChecker>,
-    checked_exprs: HashSet<HirId>,
-}
-
-impl UnsafeUnwrapVisitor<'_, '_> {
-    fn is_panic_inducing_call(&self, func: &Expr<'_>) -> bool {
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind {
-            return PANIC_INDUCING_FUNCTIONS.iter().any(|&func| {
-                path.segments
-                    .iter()
-                    .any(|segment| segment.ident.name.as_str().contains(func))
-            });
-        }
-        false
-    }
-
-    fn get_unwrap_info(&self, receiver: &Expr<'_>) -> Option<HirId> {
-        if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &receiver.kind;
-            if let Res::Local(hir_id) = path.res;
-            then {
-                return Some(hir_id);
-            }
-        }
-        None
-    }
-
-    fn set_conditional_checker(&mut self, conditional_checkers: &HashSet<ConditionalChecker>) {
-        for checker in conditional_checkers {
-            self.conditional_checker.insert(*checker);
-            if checker.check_type.is_safe_to_unwrap() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
-            }
-        }
-    }
-
-    fn reset_conditional_checker(&mut self, conditional_checkers: HashSet<ConditionalChecker>) {
-        for checker in conditional_checkers {
-            if checker.check_type.is_safe_to_unwrap() {
-                self.checked_exprs.remove(&checker.checked_expr_hir_id);
-            }
-            self.conditional_checker.remove(&checker);
-        }
-    }
-
-    /// Process conditional expressions to determine if they should halt execution.
-    fn handle_if_expressions(&mut self) {
-        self.conditional_checker.iter().for_each(|checker| {
-            if checker.check_type.should_halt_execution() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
-            }
-        });
-    }
-
-    fn is_literal_or_composed_of_literals(&self, expr: &Expr<'_>) -> bool {
-        let mut stack = vec![expr];
-
-        while let Some(current_expr) = stack.pop() {
-            match current_expr.kind {
-                ExprKind::Lit(_) => continue, // A literal is fine, continue processing.
-                ExprKind::Tup(elements) | ExprKind::Array(elements) => {
-                    stack.extend(elements);
-                }
-                ExprKind::Struct(_, fields, _) => {
-                    for field in fields {
-                        stack.push(field.expr);
-                    }
-                }
-                ExprKind::Repeat(element, _) => {
-                    stack.push(element);
-                }
-                _ => return false, // If any element is not a literal or a compound of literals, return false.
-            }
-        }
-
-        true // If the stack is emptied without finding a non-literal, all elements are literals.
-    }
-
-    fn is_method_call_unsafe(
-        &self,
-        path_segment: &PathSegment,
-        receiver: &Expr,
-        args: &[Expr],
-    ) -> bool {
-        if path_segment.ident.name == sym::unwrap {
-            return self
-                .get_unwrap_info(receiver)
-                .map_or(true, |id| !self.checked_exprs.contains(&id));
-        }
-
-        args.iter().any(|arg| self.contains_unsafe_method_call(arg))
-            || self.contains_unsafe_method_call(receiver)
-    }
-
-    fn contains_unsafe_method_call(&self, expr: &Expr) -> bool {
-        match &expr.kind {
-            ExprKind::MethodCall(path_segment, receiver, args, _) => {
-                self.is_method_call_unsafe(path_segment, receiver, args)
-            }
-            _ => false,
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UnsafeUnwrapVisitor<'a, 'tcx> {
-    fn visit_local(&mut self, local: &'tcx LetStmt<'tcx>) {
-        if let Some(init) = &local.init {
-            match init.kind {
-                ExprKind::MethodCall(path_segment, receiver, args, _) => {
-                    if self.is_method_call_unsafe(path_segment, receiver, args) {
-                        span_lint_and_help(
-                            self.cx,
-                            UNSAFE_UNWRAP,
-                            local.span,
-                            LINT_MESSAGE,
-                            None,
-                            "Please, use a custom error instead of `unwrap`",
-                        );
-                    }
-                }
-                ExprKind::Call(func, args) => {
-                    if let ExprKind::Path(QPath::Resolved(_, path)) = func.kind {
-                        let is_some_or_ok = path
-                            .segments
-                            .iter()
-                            .any(|segment| matches!(segment.ident.name, sym::Some | sym::Ok));
-                        let all_literals = args
-                            .iter()
-                            .all(|arg| self.is_literal_or_composed_of_literals(arg));
-                        if is_some_or_ok && all_literals {
-                            self.checked_exprs.insert(local.pat.hir_id);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        // If we are inside an `if` or `if let` expression, we analyze its body
-        if !self.conditional_checker.is_empty() {
-            match &expr.kind {
-                ExprKind::Ret(..) => self.handle_if_expressions(),
-                ExprKind::Call(func, _) if self.is_panic_inducing_call(func) => {
-                    self.handle_if_expressions()
-                }
-                _ => {}
-            }
-        }
-
-        // Find `if` or `if let` expressions
-        if let Some(higher::IfOrIfLet {
-            cond,
-            then: if_expr,
-            r#else: _,
-        }) = higher::IfOrIfLet::hir(expr)
-        {
-            // If we are interested in the condition (if it is a CheckType) we traverse the body.
-            let conditional_checker = ConditionalChecker::from_expression(cond);
-            self.set_conditional_checker(&conditional_checker);
-            walk_expr(self, if_expr);
-            self.reset_conditional_checker(conditional_checker);
-            return;
-        }
-
-        // If we find an unsafe `unwrap`, we raise a warning
-        if_chain! {
-            if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind;
-            if path_segment.ident.name == sym::unwrap;
-            then {
-                let receiver_hir_id = self.get_unwrap_info(receiver);
-                // If the receiver is `None`, then we asume that the `unwrap` is unsafe
-                let is_checked_safe = receiver_hir_id.map_or(false, |id| self.checked_exprs.contains(&id));
-                if !is_checked_safe {
-                    span_lint_and_help(
-                        self.cx,
-                        UNSAFE_UNWRAP,
-                        expr.span,
-                        LINT_MESSAGE,
-                        None,
-                        "Please, use a custom error instead of `unwrap`",
-                    );
-                }
-             }
-        }
-
-        walk_expr(self, expr);
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        span: Span,
-        _: LocalDefId,
-    ) {
-        // If the function comes from a macro expansion, we don't want to analyze it.
-        if span.from_expansion() {
-            return;
-        }
-
-        let mut visitor = UnsafeUnwrapVisitor {
-            cx,
-            checked_exprs: HashSet::new(),
-            conditional_checker: HashSet::new(),
-        };
-
-        walk_expr(&mut visitor, body.value);
-    }
-}
diff --git a/detectors/rust/unsafe-expect/src/lib.rs b/detectors/rust/unsafe-expect/src/lib.rs
index 6289f07d..fe2e6500 100644
--- a/detectors/rust/unsafe-expect/src/lib.rs
+++ b/detectors/rust/unsafe-expect/src/lib.rs
@@ -9,7 +9,7 @@ use common::{
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
 };
-use common_detectors::unsafe_expect::UnsafeExpectVisitor;
+use common_detectors::unsafe_checks::UnsafeChecks;
 use rustc_hir::{
     def_id::LocalDefId,
     intravisit::{walk_expr, FnKind, Visitor},
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for UnsafeExpect {
         };
         constant_analyzer.visit_body(body);
 
-        let mut visitor = UnsafeExpectVisitor::new(cx, UNSAFE_EXPECT, constant_analyzer);
+        let mut visitor = UnsafeChecks::new(cx, UNSAFE_EXPECT, constant_analyzer, sym::expect);
 
         walk_expr(&mut visitor, body.value);
     }
diff --git a/detectors/ink/unsafe-unwrap/Cargo.toml b/detectors/rust/unsafe-unwrap/Cargo.toml
similarity index 88%
rename from detectors/ink/unsafe-unwrap/Cargo.toml
rename to detectors/rust/unsafe-unwrap/Cargo.toml
index 20cd1c4b..b823222c 100644
--- a/detectors/ink/unsafe-unwrap/Cargo.toml
+++ b/detectors/rust/unsafe-unwrap/Cargo.toml
@@ -9,7 +9,7 @@ crate-type = ["cdylib"]
 [dependencies]
 clippy_utils = { workspace = true }
 common = { workspace = true }
-dylint_internal = { workspace = true }
+common_detectors = { workspace = true }
 dylint_linting = { workspace = true }
 if_chain = { workspace = true }
 
diff --git a/detectors/rust/unsafe-unwrap/src/lib.rs b/detectors/rust/unsafe-unwrap/src/lib.rs
new file mode 100644
index 00000000..2c0772a4
--- /dev/null
+++ b/detectors/rust/unsafe-unwrap/src/lib.rs
@@ -0,0 +1,64 @@
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_span;
+
+use common::{
+    analysis::ConstantAnalyzer,
+    declarations::{Severity, VulnerabilityClass},
+    macros::expose_lint_info,
+};
+use common_detectors::unsafe_checks::UnsafeChecks;
+use rustc_hir::{
+    def_id::LocalDefId,
+    intravisit::{walk_expr, FnKind, Visitor},
+    Body, FnDecl,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_span::{sym, Span};
+use std::collections::HashSet;
+
+const LINT_MESSAGE: &str = "Unsafe usage of `unwrap`";
+
+#[expose_lint_info]
+pub static UNSAFE_UNWRAP_INFO: LintInfo = LintInfo {
+    name: env!("CARGO_PKG_NAME"),
+    short_message: LINT_MESSAGE,
+    long_message: "This vulnerability class pertains to the inappropriate usage of the unwrap method in Rust, which is commonly employed for error handling. The unwrap method retrieves the inner value of an Option or Result, but if an error or None occurs, it triggers a panic and crashes the program.    ",
+    severity: Severity::Medium,
+    help: "https://coinfabrik.github.io/scout-soroban/docs/detectors/unsafe-unwrap",
+    vulnerability_class: VulnerabilityClass::ErrorHandling,
+};
+
+dylint_linting::declare_late_lint! {
+    pub UNSAFE_UNWRAP,
+    Warn,
+    LINT_MESSAGE
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        span: Span,
+        _: LocalDefId,
+    ) {
+        // If the function comes from a macro expansion we don't want to analyze it.
+        if span.from_expansion() {
+            return;
+        }
+
+        let mut constant_analyzer = ConstantAnalyzer {
+            cx,
+            constants: HashSet::new(),
+        };
+        constant_analyzer.visit_body(body);
+
+        let mut visitor = UnsafeChecks::new(cx, UNSAFE_UNWRAP, constant_analyzer, sym::unwrap);
+
+        walk_expr(&mut visitor, body.value);
+    }
+}
diff --git a/detectors/soroban/Cargo.lock b/detectors/soroban/Cargo.lock
index b87882e8..76359493 100644
--- a/detectors/soroban/Cargo.lock
+++ b/detectors/soroban/Cargo.lock
@@ -1013,17 +1013,6 @@ dependencies = [
  "if_chain",
 ]
 
-[[package]]
-name = "unsafe-unwrap"
-version = "0.1.0"
-dependencies = [
- "clippy_utils",
- "common",
- "dylint_internal",
- "dylint_linting",
- "if_chain",
-]
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
diff --git a/detectors/soroban/unsafe-unwrap/Cargo.toml b/detectors/soroban/unsafe-unwrap/Cargo.toml
deleted file mode 100644
index 2496d24a..00000000
--- a/detectors/soroban/unsafe-unwrap/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-edition = "2021"
-name = "unsafe-unwrap"
-version = "0.1.0"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-clippy_utils = { workspace = true }
-common = { workspace = true }
-dylint_internal = { workspace = true }
-dylint_linting = { workspace = true }
-if_chain = { workspace = true }
-
-
-[package.metadata.rust-analyzer]
-rustc_private = true
diff --git a/detectors/soroban/unsafe-unwrap/src/lib.rs b/detectors/soroban/unsafe-unwrap/src/lib.rs
deleted file mode 100644
index bc3c28b7..00000000
--- a/detectors/soroban/unsafe-unwrap/src/lib.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-#![feature(rustc_private)]
-#![allow(clippy::enum_variant_names)]
-
-extern crate rustc_hir;
-extern crate rustc_span;
-
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::higher::IfOrIfLet;
-use common::{
-    analysis::{fn_returns, get_node_type_opt, match_type_to_str, ConstantAnalyzer},
-    declarations::{Severity, VulnerabilityClass},
-    macros::expose_lint_info,
-};
-use if_chain::if_chain;
-use rustc_hir::{
-    def::Res,
-    def_id::LocalDefId,
-    intravisit::{walk_expr, FnKind, Visitor},
-    BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, LangItem, MatchSource, PathSegment, QPath,
-    UnOp,
-};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{sym, Span, Symbol};
-use std::{collections::HashSet, hash::Hash};
-
-const LINT_MESSAGE: &str = "Unsafe usage of `unwrap`";
-const PANIC_INDUCING_FUNCTIONS: [&str; 2] = ["panic", "bail"];
-
-#[expose_lint_info]
-pub static UNSAFE_UNWRAP_INFO: LintInfo = LintInfo {
-    name: env!("CARGO_PKG_NAME"),
-    short_message: LINT_MESSAGE,
-    long_message: "This vulnerability class pertains to the inappropriate usage of the unwrap method in Rust, which is commonly employed for error handling. The unwrap method retrieves the inner value of an Option or Result, but if an error or None occurs, it triggers a panic and crashes the program.    ",
-    severity: Severity::Medium,
-    help: "https://coinfabrik.github.io/scout-soroban/docs/detectors/unsafe-unwrap",
-    vulnerability_class: VulnerabilityClass::ErrorHandling,
-};
-
-dylint_linting::declare_late_lint! {
-    pub UNSAFE_UNWRAP,
-    Warn,
-    LINT_MESSAGE
-}
-
-// Enum to represent the type being unwrapped
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum UnwrapType {
-    Option,
-    Result,
-}
-
-/// Represents the type of check performed on method call expressions to determine their safety or behavior.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-enum CheckType {
-    IsSome,
-    IsNone,
-    IsOk,
-    IsErr,
-}
-
-impl CheckType {
-    fn from_method_name(name: Symbol) -> Option<Self> {
-        match name.as_str() {
-            "is_some" => Some(Self::IsSome),
-            "is_none" => Some(Self::IsNone),
-            "is_ok" => Some(Self::IsOk),
-            "is_err" => Some(Self::IsErr),
-            _ => None,
-        }
-    }
-
-    fn inverse(self) -> Self {
-        match self {
-            Self::IsSome => Self::IsNone,
-            Self::IsNone => Self::IsSome,
-            Self::IsOk => Self::IsErr,
-            Self::IsErr => Self::IsOk,
-        }
-    }
-
-    /// Determines if the check type implies execution should halt, such as in error conditions.
-    fn should_halt_execution(self) -> bool {
-        matches!(self, Self::IsNone | Self::IsErr)
-    }
-
-    /// Determines if it is safe to unwrap the value without further checks, i.e., the value is present.
-    fn is_safe_to_unwrap(self) -> bool {
-        matches!(self, Self::IsSome | Self::IsOk)
-    }
-}
-
-/// Represents a conditional checker that is used to analyze `if` or `if let` expressions.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-struct ConditionalChecker {
-    check_type: CheckType,
-    checked_expr_hir_id: HirId,
-}
-
-impl ConditionalChecker {
-    /// Handle te condition of the `if` or `if let` expression.
-    fn handle_condition(condition: &Expr<'_>, inverse: bool) -> HashSet<Self> {
-        if_chain! {
-            if let ExprKind::MethodCall(path_segment, receiver, _, _) = condition.kind;
-            if let Some(check_type) = CheckType::from_method_name(path_segment.ident.name);
-            if let ExprKind::Path(QPath::Resolved(_, checked_expr_path)) = receiver.kind;
-            if let Res::Local(checked_expr_hir_id) = checked_expr_path.res;
-            then {
-                let check_type = if inverse { check_type.inverse() } else { check_type };
-                return std::iter::once(Self { check_type, checked_expr_hir_id }).collect();
-            }
-        }
-        HashSet::new()
-    }
-
-    /// Constructs a ConditionalChecker from an expression if it matches a method call with a valid CheckType.
-    fn from_expression(condition: &Expr<'_>) -> HashSet<Self> {
-        match condition.kind {
-            // Single `not` expressions are supported
-            ExprKind::Unary(UnOp::Not, condition) => Self::handle_condition(condition, true),
-            // Multiple `or` expressions are supported
-            ExprKind::Binary(op, left_condition, right_condition) if op.node == BinOpKind::Or => {
-                let mut result = Self::from_expression(left_condition);
-                result.extend(Self::from_expression(right_condition));
-                result
-            }
-            ExprKind::MethodCall(..) => Self::handle_condition(condition, false),
-            _ => HashSet::new(),
-        }
-    }
-}
-
-/// Main unsafe-unwrap visitor
-struct UnsafeUnwrapVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    constant_analyzer: ConstantAnalyzer<'a, 'tcx>,
-    conditional_checker: HashSet<ConditionalChecker>,
-    checked_exprs: HashSet<HirId>,
-    linted_spans: HashSet<Span>,
-    returns_result_or_option: bool,
-}
-
-impl<'a, 'tcx> UnsafeUnwrapVisitor<'a, 'tcx> {
-    fn get_help_message(&self, unwrap_type: UnwrapType) -> &'static str {
-        match (self.returns_result_or_option, unwrap_type) {
-            (true, UnwrapType::Option) => "Consider using `ok_or` to convert Option to Result",
-            (true, UnwrapType::Result) => "Consider using the `?` operator for error propagation",
-            (false, UnwrapType::Option) => {
-                "Consider pattern matching or using `if let` instead of `unwrap`"
-            }
-            (false, UnwrapType::Result) => {
-                "Consider handling the error case explicitly or using `if let` instead of `unwrap`"
-            }
-        }
-    }
-
-    fn determine_unwrap_type(&self, receiver: &Expr<'tcx>) -> UnwrapType {
-        let type_opt = get_node_type_opt(self.cx, &receiver.hir_id);
-        if let Some(type_) = type_opt {
-            if match_type_to_str(self.cx, type_, "Result") {
-                return UnwrapType::Result;
-            }
-        }
-        UnwrapType::Option
-    }
-
-    fn is_panic_inducing_call(&self, func: &Expr<'tcx>) -> bool {
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind {
-            return PANIC_INDUCING_FUNCTIONS.iter().any(|&func| {
-                path.segments
-                    .iter()
-                    .any(|segment| segment.ident.name.as_str().contains(func))
-            });
-        }
-        false
-    }
-
-    fn get_unwrap_info(&self, receiver: &Expr<'tcx>) -> Option<HirId> {
-        if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &receiver.kind;
-            if let Res::Local(hir_id) = path.res;
-            then {
-                return Some(hir_id);
-            }
-        }
-        None
-    }
-
-    fn update_conditional_checker(
-        &mut self,
-        conditional_checkers: &HashSet<ConditionalChecker>,
-        set: bool,
-    ) {
-        for checker in conditional_checkers {
-            if set {
-                self.conditional_checker.insert(*checker);
-                if checker.check_type.is_safe_to_unwrap() {
-                    self.checked_exprs.insert(checker.checked_expr_hir_id);
-                }
-            } else {
-                if checker.check_type.is_safe_to_unwrap() {
-                    self.checked_exprs.remove(&checker.checked_expr_hir_id);
-                }
-                self.conditional_checker.remove(checker);
-            }
-        }
-    }
-
-    /// Process conditional expressions to determine if they should halt execution.
-    fn handle_if_expressions(&mut self) {
-        self.conditional_checker.iter().for_each(|checker| {
-            if checker.check_type.should_halt_execution() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
-            }
-        });
-    }
-
-    fn is_method_call_unsafe(&mut self, path_segment: &PathSegment, receiver: &Expr<'tcx>) -> bool {
-        if path_segment.ident.name == sym::unwrap {
-            if self.constant_analyzer.is_constant(receiver) {
-                return false;
-            }
-
-            return self
-                .get_unwrap_info(receiver)
-                .map_or(true, |id| !self.checked_exprs.contains(&id));
-        }
-
-        false
-    }
-
-    fn check_expr_for_unsafe_unwrap(&mut self, expr: &Expr<'tcx>) {
-        if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind {
-            if self.is_method_call_unsafe(path_segment, receiver)
-                && !self.linted_spans.contains(&expr.span)
-            {
-                let unwrap_type = self.determine_unwrap_type(receiver);
-                let help_message = self.get_help_message(unwrap_type);
-
-                span_lint_and_help(
-                    self.cx,
-                    UNSAFE_UNWRAP,
-                    expr.span,
-                    LINT_MESSAGE,
-                    None,
-                    help_message,
-                );
-                self.linted_spans.insert(expr.span);
-            }
-        }
-    }
-
-    fn check_for_try(&mut self, expr: &Expr<'tcx>) {
-        if_chain! {
-            // Check for match expressions desugared from try
-            if let ExprKind::Match(expr, _, MatchSource::TryDesugar(_)) = &expr.kind;
-            if let ExprKind::Call(func, args) = &expr.kind;
-            // Check for the try trait branch lang item
-            if let ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, _)) = &func.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &args[0].kind;
-            // Get the HirId of the expression that is being checked
-            if let Res::Local(hir_id) = path.res;
-            then {
-                self.checked_exprs.insert(hir_id);
-            }
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UnsafeUnwrapVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        // Check for try expressions (desugared from `?`)
-        self.check_for_try(expr);
-
-        // If we are inside an `if` or `if let` expression, we analyze its body
-        if !self.conditional_checker.is_empty() {
-            match &expr.kind {
-                ExprKind::Ret(..) => self.handle_if_expressions(),
-                ExprKind::Call(func, _) if self.is_panic_inducing_call(func) => {
-                    self.handle_if_expressions()
-                }
-                _ => {}
-            }
-        }
-
-        // Find `if` or `if let` expressions
-        if let Some(IfOrIfLet {
-            cond,
-            then: if_expr,
-            r#else: _,
-        }) = IfOrIfLet::hir(expr)
-        {
-            // If we are interested in the condition (if it is a CheckType) we traverse the body.
-            let conditional_checker = ConditionalChecker::from_expression(cond);
-            self.update_conditional_checker(&conditional_checker, true);
-            walk_expr(self, if_expr);
-            self.update_conditional_checker(&conditional_checker, false);
-            return;
-        }
-
-        // If we find an unsafe `unwrap`, we raise a warning
-        self.check_expr_for_unsafe_unwrap(expr);
-
-        walk_expr(self, expr);
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        fn_decl: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        span: Span,
-        _: LocalDefId,
-    ) {
-        // If the function comes from a macro expansion, we don't want to analyze it.
-        if span.from_expansion() {
-            return;
-        }
-
-        let mut constant_analyzer = ConstantAnalyzer {
-            cx,
-            constants: HashSet::new(),
-        };
-        constant_analyzer.visit_body(body);
-
-        let mut visitor = UnsafeUnwrapVisitor {
-            cx,
-            constant_analyzer,
-            checked_exprs: HashSet::new(),
-            conditional_checker: HashSet::new(),
-            linted_spans: HashSet::new(),
-            returns_result_or_option: fn_returns(fn_decl, sym::Result)
-                || fn_returns(fn_decl, sym::Option),
-        };
-
-        walk_expr(&mut visitor, body.value);
-    }
-}
diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index b98c6ba7..c4fa4ac5 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -2841,7 +2841,7 @@ version = "0.1.0"
 dependencies = [
  "clippy_utils",
  "common",
- "dylint_internal",
+ "common-detectors",
  "dylint_linting",
  "if_chain",
 ]
diff --git a/detectors/substrate-pallets/unsafe-expect/src/lib.rs b/detectors/substrate-pallets/unsafe-expect/src/lib.rs
index 3afee9da..33fb3706 100644
--- a/detectors/substrate-pallets/unsafe-expect/src/lib.rs
+++ b/detectors/substrate-pallets/unsafe-expect/src/lib.rs
@@ -9,14 +9,14 @@ use common::{
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
 };
-use common_detectors::unsafe_expect::UnsafeExpectVisitor;
+use common_detectors::unsafe_checks::UnsafeChecks;
 use rustc_hir::{
     def_id::LocalDefId,
     intravisit::{walk_expr, FnKind, Visitor},
     Body, FnDecl,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use std::collections::HashSet;
 
 const LINT_MESSAGE: &str = "Unsafe usage of `expect`";
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for UnsafeExpect {
         };
         constant_analyzer.visit_body(body);
 
-        let mut visitor = UnsafeExpectVisitor::new(cx, UNSAFE_EXPECT, constant_analyzer);
+        let mut visitor = UnsafeChecks::new(cx, UNSAFE_EXPECT, constant_analyzer, sym::expect);
 
         walk_expr(&mut visitor, body.value);
     }
diff --git a/detectors/substrate-pallets/unsafe-unwrap/Cargo.toml b/detectors/substrate-pallets/unsafe-unwrap/Cargo.toml
index 20cd1c4b..b823222c 100644
--- a/detectors/substrate-pallets/unsafe-unwrap/Cargo.toml
+++ b/detectors/substrate-pallets/unsafe-unwrap/Cargo.toml
@@ -9,7 +9,7 @@ crate-type = ["cdylib"]
 [dependencies]
 clippy_utils = { workspace = true }
 common = { workspace = true }
-dylint_internal = { workspace = true }
+common_detectors = { workspace = true }
 dylint_linting = { workspace = true }
 if_chain = { workspace = true }
 
diff --git a/detectors/substrate-pallets/unsafe-unwrap/src/lib.rs b/detectors/substrate-pallets/unsafe-unwrap/src/lib.rs
index 685c6654..afed031f 100644
--- a/detectors/substrate-pallets/unsafe-unwrap/src/lib.rs
+++ b/detectors/substrate-pallets/unsafe-unwrap/src/lib.rs
@@ -1,28 +1,24 @@
 #![feature(rustc_private)]
-#![allow(clippy::enum_variant_names)]
 
 extern crate rustc_hir;
 extern crate rustc_span;
 
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::higher;
 use common::{
+    analysis::ConstantAnalyzer,
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
 };
-use if_chain::if_chain;
+use common_detectors::unsafe_checks::UnsafeChecks;
 use rustc_hir::{
-    def::Res,
     def_id::LocalDefId,
     intravisit::{walk_expr, FnKind, Visitor},
-    BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, PathSegment, QPath, UnOp,
+    Body, FnDecl,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{sym, Span, Symbol};
-use std::{collections::HashSet, hash::Hash};
+use rustc_span::{sym, Span};
+use std::collections::HashSet;
 
 const LINT_MESSAGE: &str = "Unsafe usage of `unwrap`";
-const PANIC_INDUCING_FUNCTIONS: [&str; 2] = ["panic", "bail"];
 
 #[expose_lint_info]
 pub static UNSAFE_UNWRAP_INFO: LintInfo = LintInfo {
@@ -40,285 +36,6 @@ dylint_linting::declare_late_lint! {
     LINT_MESSAGE
 }
 
-/// Represents the type of check performed on method call expressions to determine their safety or behavior.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-enum CheckType {
-    IsSome,
-    IsNone,
-    IsOk,
-    IsErr,
-}
-
-impl CheckType {
-    fn from_method_name(name: Symbol) -> Option<Self> {
-        match name.as_str() {
-            "is_some" => Some(Self::IsSome),
-            "is_none" => Some(Self::IsNone),
-            "is_ok" => Some(Self::IsOk),
-            "is_err" => Some(Self::IsErr),
-            _ => None,
-        }
-    }
-
-    fn inverse(self) -> Self {
-        match self {
-            Self::IsSome => Self::IsNone,
-            Self::IsNone => Self::IsSome,
-            Self::IsOk => Self::IsErr,
-            Self::IsErr => Self::IsOk,
-        }
-    }
-
-    /// Determines if the check type implies execution should halt, such as in error conditions.
-    fn should_halt_execution(self) -> bool {
-        matches!(self, Self::IsNone | Self::IsErr)
-    }
-
-    /// Determines if it is safe to unwrap the value without further checks, i.e., the value is present.
-    fn is_safe_to_unwrap(self) -> bool {
-        matches!(self, Self::IsSome | Self::IsOk)
-    }
-}
-
-/// Represents a conditional checker that is used to analyze `if` or `if let` expressions.
-#[derive(Clone, Copy, Hash, Eq, PartialEq)]
-struct ConditionalChecker {
-    check_type: CheckType,
-    checked_expr_hir_id: HirId,
-}
-
-impl ConditionalChecker {
-    /// Handle te condition of the `if` or `if let` expression.
-    fn handle_condition(condition: &Expr<'_>, inverse: bool) -> HashSet<Self> {
-        if_chain! {
-            if let ExprKind::MethodCall(path_segment, receiver, _, _) = condition.kind;
-            if let Some(check_type) = CheckType::from_method_name(path_segment.ident.name);
-            if let ExprKind::Path(QPath::Resolved(_, checked_expr_path)) = receiver.kind;
-            if let Res::Local(checked_expr_hir_id) = checked_expr_path.res;
-            then {
-                let check_type = if inverse { check_type.inverse() } else { check_type };
-                return std::iter::once(Self { check_type, checked_expr_hir_id }).collect();
-            }
-        }
-        HashSet::new()
-    }
-
-    /// Constructs a ConditionalChecker from an expression if it matches a method call with a valid CheckType.
-    fn from_expression(condition: &Expr<'_>) -> HashSet<Self> {
-        match condition.kind {
-            // Single `not` expressions are supported
-            ExprKind::Unary(op, condition) => Self::handle_condition(condition, op == UnOp::Not),
-            // Multiple `or` expressions are supported
-            ExprKind::Binary(op, left_condition, right_condition) if op.node == BinOpKind::Or => {
-                let mut result = Self::from_expression(left_condition);
-                result.extend(Self::from_expression(right_condition));
-                result
-            }
-            ExprKind::MethodCall(..) => Self::handle_condition(condition, false),
-            _ => HashSet::new(),
-        }
-    }
-}
-
-/// Main unsafe-unwrap visitor
-struct UnsafeUnwrapVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    conditional_checker: HashSet<ConditionalChecker>,
-    checked_exprs: HashSet<HirId>,
-}
-
-impl UnsafeUnwrapVisitor<'_, '_> {
-    fn is_panic_inducing_call(&self, func: &Expr<'_>) -> bool {
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind {
-            return PANIC_INDUCING_FUNCTIONS.iter().any(|&func| {
-                path.segments
-                    .iter()
-                    .any(|segment| segment.ident.name.as_str().contains(func))
-            });
-        }
-        false
-    }
-
-    fn get_unwrap_info(&self, receiver: &Expr<'_>) -> Option<HirId> {
-        if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &receiver.kind;
-            if let Res::Local(hir_id) = path.res;
-            then {
-                return Some(hir_id);
-            }
-        }
-        None
-    }
-
-    fn set_conditional_checker(&mut self, conditional_checkers: &HashSet<ConditionalChecker>) {
-        for checker in conditional_checkers {
-            self.conditional_checker.insert(*checker);
-            if checker.check_type.is_safe_to_unwrap() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
-            }
-        }
-    }
-
-    fn reset_conditional_checker(&mut self, conditional_checkers: HashSet<ConditionalChecker>) {
-        for checker in conditional_checkers {
-            if checker.check_type.is_safe_to_unwrap() {
-                self.checked_exprs.remove(&checker.checked_expr_hir_id);
-            }
-            self.conditional_checker.remove(&checker);
-        }
-    }
-
-    /// Process conditional expressions to determine if they should halt execution.
-    fn handle_if_expressions(&mut self) {
-        self.conditional_checker.iter().for_each(|checker| {
-            if checker.check_type.should_halt_execution() {
-                self.checked_exprs.insert(checker.checked_expr_hir_id);
-            }
-        });
-    }
-
-    fn is_literal_or_composed_of_literals(&self, expr: &Expr<'_>) -> bool {
-        let mut stack = vec![expr];
-
-        while let Some(current_expr) = stack.pop() {
-            match current_expr.kind {
-                ExprKind::Lit(_) => continue, // A literal is fine, continue processing.
-                ExprKind::Tup(elements) | ExprKind::Array(elements) => {
-                    stack.extend(elements);
-                }
-                ExprKind::Struct(_, fields, _) => {
-                    for field in fields {
-                        stack.push(field.expr);
-                    }
-                }
-                ExprKind::Repeat(element, _) => {
-                    stack.push(element);
-                }
-                _ => return false, // If any element is not a literal or a compound of literals, return false.
-            }
-        }
-
-        true // If the stack is emptied without finding a non-literal, all elements are literals.
-    }
-
-    fn is_method_call_unsafe(
-        &self,
-        path_segment: &PathSegment,
-        receiver: &Expr,
-        args: &[Expr],
-    ) -> bool {
-        if path_segment.ident.name == sym::unwrap {
-            return self
-                .get_unwrap_info(receiver)
-                .map_or(true, |id| !self.checked_exprs.contains(&id));
-        }
-
-        args.iter().any(|arg| self.contains_unsafe_method_call(arg))
-            || self.contains_unsafe_method_call(receiver)
-    }
-
-    fn contains_unsafe_method_call(&self, expr: &Expr) -> bool {
-        match &expr.kind {
-            ExprKind::MethodCall(path_segment, receiver, args, _) => {
-                self.is_method_call_unsafe(path_segment, receiver, args)
-            }
-            _ => false,
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UnsafeUnwrapVisitor<'a, 'tcx> {
-    fn visit_local(&mut self, local: &'tcx rustc_hir::LetStmt<'tcx>) {
-        if let Some(init) = local.init {
-            match init.kind {
-                ExprKind::MethodCall(path_segment, receiver, args, _) => {
-                    if self.is_method_call_unsafe(path_segment, receiver, args) {
-                        span_lint_and_help(
-                            self.cx,
-                            UNSAFE_UNWRAP,
-                            local.span,
-                            LINT_MESSAGE,
-                            None,
-                            "Please, use a custom error instead of `unwrap`",
-                        );
-                    }
-                }
-                ExprKind::Call(func, args) => {
-                    if let ExprKind::Path(QPath::Resolved(_, path)) = func.kind {
-                        let is_some_or_ok = path
-                            .segments
-                            .iter()
-                            .any(|segment| matches!(segment.ident.name, sym::Some | sym::Ok));
-                        let all_literals = args
-                            .iter()
-                            .all(|arg| self.is_literal_or_composed_of_literals(arg));
-                        if is_some_or_ok && all_literals {
-                            self.checked_exprs.insert(local.pat.hir_id);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        // Skip macro-generated code early
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        // If we are inside an `if` or `if let` expression, we analyze its body
-        if !self.conditional_checker.is_empty() {
-            match &expr.kind {
-                ExprKind::Ret(..) => self.handle_if_expressions(),
-                ExprKind::Call(func, _) if self.is_panic_inducing_call(func) => {
-                    self.handle_if_expressions()
-                }
-                _ => {}
-            }
-        }
-
-        // Find `if` or `if let` expressions
-        if let Some(higher::IfOrIfLet {
-            cond,
-            then: if_expr,
-            r#else: _,
-        }) = higher::IfOrIfLet::hir(expr)
-        {
-            // If we are interested in the condition (if it is a CheckType) we traverse the body.
-            let conditional_checker = ConditionalChecker::from_expression(cond);
-            self.set_conditional_checker(&conditional_checker);
-            walk_expr(self, if_expr);
-            self.reset_conditional_checker(conditional_checker);
-            return;
-        }
-
-        // If we find an unsafe `unwrap`, we raise a warning
-        if_chain! {
-            if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind;
-            if path_segment.ident.name == sym::unwrap;
-            then {
-                let receiver_hir_id = self.get_unwrap_info(receiver);
-                // If the receiver is `None`, then we asume that the `unwrap` is unsafe
-                let is_checked_safe = receiver_hir_id.map_or(false, |id| self.checked_exprs.contains(&id));
-                if !is_checked_safe {
-                    span_lint_and_help(
-                        self.cx,
-                        UNSAFE_UNWRAP,
-                        expr.span,
-                        LINT_MESSAGE,
-                        None,
-                        "Please, use a custom error instead of `unwrap`",
-                    );
-                }
-             }
-        }
-
-        walk_expr(self, expr);
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
     fn check_fn(
         &mut self,
@@ -329,11 +46,13 @@ impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
         _: Span,
         _: LocalDefId,
     ) {
-        let mut visitor = UnsafeUnwrapVisitor {
+        let mut constant_analyzer = ConstantAnalyzer {
             cx,
-            checked_exprs: HashSet::new(),
-            conditional_checker: HashSet::new(),
+            constants: HashSet::new(),
         };
+        constant_analyzer.visit_body(body);
+
+        let mut visitor = UnsafeChecks::new(cx, UNSAFE_UNWRAP, constant_analyzer, sym::unwrap);
 
         walk_expr(&mut visitor, body.value);
     }

From 09de7503f77da26cbfa63eb00bc3fc67ca45e8b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Thu, 5 Dec 2024 17:47:46 -0300
Subject: [PATCH 14/30] Fixed build error.

---
 apps/cargo-scout-audit/src/scout/nightly_runner.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/cargo-scout-audit/src/scout/nightly_runner.rs b/apps/cargo-scout-audit/src/scout/nightly_runner.rs
index 2affa3c4..51d4df9c 100644
--- a/apps/cargo-scout-audit/src/scout/nightly_runner.rs
+++ b/apps/cargo-scout-audit/src/scout/nightly_runner.rs
@@ -23,7 +23,7 @@ pub fn run_scout_in_nightly(toolchain: &str) -> Result<Option<Child>> {
     use windows::{core::PCWSTR, Win32::System::LibraryLoader::SetDllDirectoryW};
 
     let user_profile = env::var("USERPROFILE")
-        .map_err(|e| anyhow!("Unable to get user profile directory: {e}"))?;
+        .map_err(|e| anyhow::anyhow!("Unable to get user profile directory: {e}"))?;
     let mut user_profile = std::path::PathBuf::from(user_profile);
     user_profile.push(".rustup");
     user_profile.push("toolchains");

From 7fc9dba8295a8eddda18366c19c2a71edae90999 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Thu, 5 Dec 2024 17:51:22 -0300
Subject: [PATCH 15/30] test_finding_presence() should ignore
 known_vulnerabilities.

---
 apps/cargo-scout-audit/tests/main.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/apps/cargo-scout-audit/tests/main.rs b/apps/cargo-scout-audit/tests/main.rs
index 878ab327..7ed4acb7 100644
--- a/apps/cargo-scout-audit/tests/main.rs
+++ b/apps/cargo-scout-audit/tests/main.rs
@@ -241,7 +241,11 @@ mod tests {
         assert!(result.is_ok(), "Scout should run");
         let result = result.unwrap();
 
-        let findings = result.iter().map(|value| value.code()).collect::<Vec<_>>();
+        let findings = result
+            .iter()
+            .map(|value| value.code())
+            .filter(|x| x != "known_vulnerabilities")
+            .collect::<Vec<_>>();
         let counts = count_strings(&findings);
         assert!(counts.is_some(), "Scout returned data in an invalid format");
         let counts = counts.unwrap();

From 4ce85d9172390a5a51df20f98cc9887085d94bbe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?= <helios.vmg@gmail.com>
Date: Fri, 6 Dec 2024 10:56:50 -0300
Subject: [PATCH 16/30] Filtered out false positives.

---
 common/Cargo.lock                             | 177 +++++++++++++++++-
 common/analysis/Cargo.toml                    |   2 +
 common/analysis/src/decomposers.rs            |  12 +-
 common/analysis/src/double_pass.rs            |  23 +++
 common/analysis/src/lib.rs                    |   4 +
 common/analysis/src/type_utils.rs             |  26 +++
 common/detectors/Cargo.lock                   |   2 +
 .../detectors/src/iterators_over_indexing.rs  |  21 +--
 detectors/ink/Cargo.lock                      |   2 +
 detectors/soroban/Cargo.lock                  |   2 +
 detectors/substrate-pallets/Cargo.lock        |  12 ++
 .../saturating-arithmetic/Cargo.toml          |  16 ++
 .../saturating-arithmetic/src/lib.rs          | 175 +++++++++++++++++
 test-cases/substrate-pallets/Cargo.lock       |  30 +++
 .../vulnerable/vulnerable-1/Cargo.toml        |   2 -
 .../vulnerable/vulnerable-1/src/lib.rs        |  28 ---
 .../vulnerable/vulnerable-1/src/tests.rs      |  11 --
 .../vulnerable/vulnerable-2/Cargo.toml        |   2 -
 18 files changed, 482 insertions(+), 65 deletions(-)
 create mode 100644 common/analysis/src/double_pass.rs
 create mode 100644 detectors/substrate-pallets/saturating-arithmetic/Cargo.toml
 create mode 100644 detectors/substrate-pallets/saturating-arithmetic/src/lib.rs

diff --git a/common/Cargo.lock b/common/Cargo.lock
index be22defa..b0d916cd 100644
--- a/common/Cargo.lock
+++ b/common/Cargo.lock
@@ -7,9 +7,17 @@ name = "analysis"
 version = "0.1.0"
 dependencies = [
  "clippy_utils",
+ "dylint_linting",
  "if_chain",
+ "paste",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7"
+
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -22,6 +30,38 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "camino"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "clippy_config"
 version = "0.1.81"
@@ -29,7 +69,7 @@ source = "git+https://github.com/rust-lang/rust-clippy?rev=51a1cf0#51a1cf07876d3
 dependencies = [
  "rustc-semver",
  "serde",
- "toml",
+ "toml 0.7.8",
 ]
 
 [[package]]
@@ -58,7 +98,35 @@ name = "declarations"
 version = "0.1.0"
 dependencies = [
  "serde",
- "thiserror",
+ "thiserror 2.0.3",
+]
+
+[[package]]
+name = "dylint_internal"
+version = "3.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c0765e595bad79b47a2be4abfa4813a7ac082b2df0f6e863a0422dc9090c7c3"
+dependencies = [
+ "anyhow",
+ "cargo_metadata",
+ "serde",
+ "thiserror 1.0.69",
+ "toml 0.8.19",
+]
+
+[[package]]
+name = "dylint_linting"
+version = "3.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3daa5f7dca7ae5e355cdb121f8d07edd0b914e54173461209dddb85316ecbd63"
+dependencies = [
+ "cargo_metadata",
+ "dylint_internal",
+ "paste",
+ "rustversion",
+ "serde",
+ "thiserror 1.0.69",
+ "toml 0.8.19",
 ]
 
 [[package]]
@@ -104,6 +172,12 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+
 [[package]]
 name = "macros"
 version = "0.1.0"
@@ -119,6 +193,12 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.89"
@@ -153,6 +233,27 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "semver"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.215"
@@ -173,6 +274,18 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "serde_json"
+version = "1.0.133"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "0.6.8"
@@ -199,13 +312,33 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.3",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
@@ -228,7 +361,19 @@ dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.22",
 ]
 
 [[package]]
@@ -250,7 +395,20 @@ dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "winnow",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow 0.6.20",
 ]
 
 [[package]]
@@ -267,3 +425,12 @@ checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
 dependencies = [
  "memchr",
 ]
+
+[[package]]
+name = "winnow"
+version = "0.6.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
+dependencies = [
+ "memchr",
+]
diff --git a/common/analysis/Cargo.toml b/common/analysis/Cargo.toml
index 2ef25f6e..b52732a8 100644
--- a/common/analysis/Cargo.toml
+++ b/common/analysis/Cargo.toml
@@ -6,6 +6,8 @@ version = "0.1.0"
 [dependencies]
 if_chain = "=1.0.2"
 clippy_utils = { git = "https://github.com/rust-lang/rust-clippy", rev = "51a1cf0" }
+paste = "1.0"
+dylint_linting = "=3.1.2"
 
 [package.metadata.rust-analyzer]
 rustc_private = true
diff --git a/common/analysis/src/decomposers.rs b/common/analysis/src/decomposers.rs
index 4e45c187..401c6ebe 100644
--- a/common/analysis/src/decomposers.rs
+++ b/common/analysis/src/decomposers.rs
@@ -9,7 +9,7 @@ use rustc_ast::{BindingMode, Label, LitIntType, LitKind};
 use rustc_hir::{
     def::Res,
     Block, Expr, ExprField, ExprKind, HirId, LangItem, LoopSource, MatchSource, Pat, PatField,
-    PatKind, Path, QPath, StmtKind, Ty,
+    PatKind, Path, QPath, StmtKind, Ty, PathSegment,
 };
 use rustc_middle::ty::{TyCtxt, TyKind};
 use rustc_span::{symbol::Ident, Span};
@@ -70,6 +70,16 @@ pub fn expr_to_call<'hir>(
     }
 }
 
+pub fn expr_to_method_call<'hir>(
+    kind: &'hir ExprKind<'hir>,
+) -> Option<(&'hir PathSegment<'hir>, &'hir Expr<'hir>, &'hir [Expr<'hir>], Span)> {
+    if let ExprKind::MethodCall(a, b, c, d) = kind {
+        Some((a, b, c, *d))
+    } else {
+        None
+    }
+}
+
 pub fn expr_to_path<'hir>(kind: &'hir ExprKind<'hir>) -> Option<QPath<'hir>> {
     if let ExprKind::Path(a) = kind {
         Some(*a)
diff --git a/common/analysis/src/double_pass.rs b/common/analysis/src/double_pass.rs
new file mode 100644
index 00000000..f81a9f41
--- /dev/null
+++ b/common/analysis/src/double_pass.rs
@@ -0,0 +1,23 @@
+#[macro_export]
+macro_rules! declare_double_lint {
+    ($(#[$attr:meta])* $vis:vis $NAME:ident, $Level:ident, $desc:expr) => {
+        $crate::paste::paste! {
+            $crate::dylint_linting::dylint_library!();
+
+            extern crate rustc_lint;
+            extern crate rustc_session;
+
+            #[no_mangle]
+            #[allow(clippy::no_mangle_with_rust_abi)]
+            pub fn register_lints(sess: &rustc_session::Session, lint_store: &mut rustc_lint::LintStore) {
+                dylint_linting::init_config(sess);
+                lint_store.register_lints(&[$NAME]);
+                lint_store.register_early_pass(|| Box::new([< $NAME:camel >]));
+                lint_store.register_late_pass(|_| Box::new([< $NAME:camel >]));
+            }
+
+            rustc_session::declare_lint!($(#[$attr])* $vis $NAME, $Level, $desc);
+            rustc_session::declare_lint_pass!([< $NAME:camel >] => [$NAME]);
+        }
+    };
+}
diff --git a/common/analysis/src/lib.rs b/common/analysis/src/lib.rs
index a65fa211..261dbd66 100644
--- a/common/analysis/src/lib.rs
+++ b/common/analysis/src/lib.rs
@@ -1,5 +1,8 @@
 #![feature(rustc_private)]
 
+pub use paste;
+pub use dylint_linting;
+
 mod function_call_visitor;
 pub use function_call_visitor::FunctionCallVisitor;
 
@@ -19,3 +22,4 @@ mod token_interface_utils;
 pub use token_interface_utils::*;
 
 pub mod decomposers;
+pub mod double_pass;
diff --git a/common/analysis/src/type_utils.rs b/common/analysis/src/type_utils.rs
index 31dac948..c8b83199 100644
--- a/common/analysis/src/type_utils.rs
+++ b/common/analysis/src/type_utils.rs
@@ -41,3 +41,29 @@ pub fn is_macro_expansion(span: Span) -> bool {
         || span.in_derive_expansion()
         || span.ctxt().outer_expn_data().macro_def_id.is_some()
 }
+
+/// Get the fully-qualified name of a Ty
+pub fn ty_to_string(cx: &LateContext<'_>, ty: &Ty<'_>) -> Option<String>{
+    let kind = ty.kind();
+    match kind{
+        TyKind::Bool => Some("bool".to_string()),
+        TyKind::Char => Some("char".to_string()),
+        TyKind::Int(x) => Some(x.name_str().to_string()),
+        TyKind::Uint(x) => Some(x.name_str().to_string()),
+        TyKind::Float(x) => Some(x.name_str().to_string()),
+        TyKind::Str => Some("str".to_string()),
+        TyKind::Adt(def, ..) => {
+            let type_name = cx
+                .get_def_path(def.did())
+                .iter()
+                .map(|x| x.to_string())
+                .collect::<Vec<_>>()
+                .join("::");
+            Some(type_name)
+        },
+        _ => {
+            //dbg!(kind);
+            None
+        }
+    }
+}
diff --git a/common/detectors/Cargo.lock b/common/detectors/Cargo.lock
index 8f7e6ad9..f3a13acc 100644
--- a/common/detectors/Cargo.lock
+++ b/common/detectors/Cargo.lock
@@ -7,7 +7,9 @@ name = "analysis"
 version = "0.1.0"
 dependencies = [
  "clippy_utils",
+ "dylint_linting",
  "if_chain",
+ "paste",
 ]
 
 [[package]]
diff --git a/common/detectors/src/iterators_over_indexing.rs b/common/detectors/src/iterators_over_indexing.rs
index cac9fdf8..752b3d98 100644
--- a/common/detectors/src/iterators_over_indexing.rs
+++ b/common/detectors/src/iterators_over_indexing.rs
@@ -90,29 +90,18 @@ impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
         match kind {
             ExprKind::Path(object_path) => {
                 if arguments.len() != 1 {
-                    return Some(());
+                    None?;
                 }
                 let index = &arguments.first().unwrap().kind;
 
                 self.handle_path(object_path, index)
             }
-            _ => Some(()),
+            _ => None,
         }
     }
 
     fn get_id_type(&mut self, id: &HirId) -> Option<String> {
-        let object_type = get_node_type(self.cx, id);
-        let kind = object_type.kind();
-        let (def, _generic_args) = type_to_adt(kind)?;
-        let type_name = self
-            .cx
-            .get_def_path(def.did())
-            .iter()
-            .map(|x| x.to_string())
-            .collect::<Vec<_>>()
-            .join("::");
-
-        Some(type_name)
+        analysis::ty_to_string(self.cx, &get_node_type(self.cx, id))
     }
 
     fn get_path_type(&mut self, object_path: &'_ QPath<'_>) -> Option<String> {
@@ -139,13 +128,13 @@ impl<'a, 'b, 'c> VectorAccessVisitor<'a, 'b, 'c> {
 
     fn final_check(&mut self, object_type: &String, index: &'a ExprKind<'a>) -> Option<()> {
         if !self.config.relevant_object_types.contains(object_type) {
-            return Some(());
+            None?;
         }
 
         if self.get_expression_id(index)? == self.index_id {
             self.has_vector_access = true;
         }
-        Some(())
+        None
     }
 }
 
diff --git a/detectors/ink/Cargo.lock b/detectors/ink/Cargo.lock
index 04277605..002dce25 100644
--- a/detectors/ink/Cargo.lock
+++ b/detectors/ink/Cargo.lock
@@ -13,7 +13,9 @@ name = "analysis"
 version = "0.1.0"
 dependencies = [
  "clippy_utils",
+ "dylint_linting",
  "if_chain",
+ "paste",
 ]
 
 [[package]]
diff --git a/detectors/soroban/Cargo.lock b/detectors/soroban/Cargo.lock
index b87882e8..e2a4ce4a 100644
--- a/detectors/soroban/Cargo.lock
+++ b/detectors/soroban/Cargo.lock
@@ -13,7 +13,9 @@ name = "analysis"
 version = "0.1.0"
 dependencies = [
  "clippy_utils",
+ "dylint_linting",
  "if_chain",
+ "paste",
 ]
 
 [[package]]
diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index b98c6ba7..5358fbdd 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -40,7 +40,9 @@ name = "analysis"
 version = "0.1.0"
 dependencies = [
  "clippy_utils",
+ "dylint_linting",
  "if_chain",
+ "paste",
 ]
 
 [[package]]
@@ -2284,6 +2286,16 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "saturating-arithmetic"
+version = "0.1.0"
+dependencies = [
+ "clippy_utils",
+ "common",
+ "dylint_internal",
+ "dylint_linting",
+]
+
 [[package]]
 name = "schannel"
 version = "0.1.26"
diff --git a/detectors/substrate-pallets/saturating-arithmetic/Cargo.toml b/detectors/substrate-pallets/saturating-arithmetic/Cargo.toml
new file mode 100644
index 00000000..0459f631
--- /dev/null
+++ b/detectors/substrate-pallets/saturating-arithmetic/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+edition = "2021"
+name = "saturating-arithmetic"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+clippy_utils = { workspace = true }
+common = { workspace = true }
+dylint_internal = { workspace = true }
+dylint_linting = { workspace = true }
+
+[package.metadata.rust-analyzer]
+rustc_private = true
diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
new file mode 100644
index 00000000..727e083d
--- /dev/null
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -0,0 +1,175 @@
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_hir;
+extern crate rustc_span;
+extern crate rustc_middle;
+
+use clippy_utils::diagnostics::span_lint_and_help;
+use common::{
+    declarations::{Severity, VulnerabilityClass},
+    macros::expose_lint_info,
+};
+use rustc_hir::{
+    def_id::LocalDefId,
+    intravisit::{walk_expr, walk_fn, FnKind, Visitor},
+    Body, BodyId, Expr, ExprKind, FnDecl, Mod, HirId,
+};
+use rustc_ast::{
+    NodeId,
+};
+use rustc_middle::middle::privacy::Level;
+use rustc_lint::{
+    EarlyContext,
+    EarlyLintPass,
+    LateContext,
+    LateLintPass,
+};
+use rustc_span::Span;
+use common::analysis::{
+    get_node_type,
+    is_macro_expansion,
+    decomposers::*,
+};
+use std::{
+    collections::HashSet, ops::Deref, sync::{Arc, Mutex, MutexGuard}
+};
+
+const LINT_MESSAGE: &str = "Saturating arithmetic may silently generate incorrect results.";
+const LINT_HELP: &str = "Instead of overflowing, saturating arithmetic clamps the result to the representation limit for the data type. Consider checked arithmetic instead.";
+const RELEVANT_FUNCTIONS: [&str; 6] = [
+    "saturating_add",
+    "saturating_add_signed",
+    "saturating_sub",
+    "saturating_mul",
+    "saturating_div",
+    "saturating_pow",
+];
+const IGNORED_FUNCTIONS: [&str; 1] = [
+    "size_hint",
+];
+const IGNORED_TYPES: [&str; 1] = [
+    "sp_weights::weight_v2::Weight",
+];
+
+#[expose_lint_info]
+pub static SATURATING_ARITHMETIC_INFO: LintInfo = LintInfo {
+    name: env!("CARGO_PKG_NAME"),
+    short_message: LINT_MESSAGE,
+    long_message: LINT_MESSAGE,
+    severity: Severity::Critical,
+    help: "https://coinfabrik.github.io/scout/docs/vulnerabilities/incorrect-exponentiation",
+    vulnerability_class: VulnerabilityClass::Arithmetic,
+};
+
+dylint_linting::declare_late_lint! {
+    pub SATURATING_ARITHMETIC,
+    Warn,
+    LINT_MESSAGE
+}
+
+struct GlobalState{
+    relevant_functions: HashSet<String>,
+    ignored_functions: HashSet<String>,
+    ignored_types: HashSet<String>,
+}
+
+impl GlobalState{
+    pub fn new() -> Self{
+        GlobalState{
+            relevant_functions: Self::to_hash_set(&RELEVANT_FUNCTIONS[..]),
+            ignored_functions: Self::to_hash_set(&IGNORED_FUNCTIONS[..]),
+            ignored_types: Self::to_hash_set(&IGNORED_TYPES[..]),
+        }
+    }
+    fn to_hash_set(strings: &[&str]) -> HashSet<String>{
+        strings
+            .iter()
+            .map(|x| x.to_string())
+            .collect::<HashSet<_>>()
+    }
+    fn get_state() -> Arc<Mutex<GlobalState>>{
+        let mut gs = GLOBAL_STATE.lock().unwrap();
+        match gs.deref(){
+            None => {
+                let ret = Arc::<Mutex<GlobalState>>::new(Mutex::<GlobalState>::new(GlobalState::new()));
+                *gs = Some(ret.clone());
+                ret
+            },
+            Some(p) => p.clone(),
+        }
+    }
+    pub fn method_is_relevant(method_name: &str) -> bool{
+        let gs = Self::get_state();
+        let lock = gs.lock().unwrap();
+        lock.relevant_functions.contains(method_name)
+    }
+    pub fn type_is_ignored(name: &Option<String>) -> bool{
+        if let Some(name) = name{
+            let gs = Self::get_state();
+            let lock = gs.lock().unwrap();
+            lock.ignored_types.contains(name.as_str())
+        }else{
+            false
+        }
+    }
+    pub fn function_is_ignored(name: &String) -> bool{
+        let gs = Self::get_state();
+        let lock = gs.lock().unwrap();
+        lock.ignored_functions.contains(name.as_str())
+    }
+}
+
+static GLOBAL_STATE: Mutex<Option<Arc<Mutex<GlobalState>>>> = Mutex::new(None);
+
+fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()>{
+    let (method_name, receiver, _args, _span) = expr_to_method_call(&expr.kind)?;
+    if !GlobalState::method_is_relevant(method_name.ident.name.as_str()){
+        None?;        
+    }
+    let node_type = get_node_type(cx, &receiver.hir_id);
+    if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)){
+        None?;
+    }
+    
+    None
+}
+
+fn ident<'a>(f: &FnKind<'a>) -> String{
+    match f{
+        FnKind::ItemFn(id, _, _) => id.name.to_ident_string(),
+        FnKind::Method(id, _) => id.name.to_ident_string(),
+        FnKind::Closure => "<closure>".to_string()
+    }
+}
+
+struct SaturatingFinder<'a, 'b>{
+    cx: &'b LateContext<'a>,
+}
+
+impl<'a, 'b> Visitor<'a> for SaturatingFinder<'a, 'b> {
+    fn visit_expr(&mut self, expr: &'a rustc_hir::Expr<'a>) {
+        let _ = detect_saturating_call(self.cx, expr);
+        walk_expr(self, expr);
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for SaturatingArithmetic {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        _: Span,
+        ldid: LocalDefId,
+    ){
+        if GlobalState::function_is_ignored(&ident(&kind)){
+            return;
+        }
+
+        SaturatingFinder{
+            cx,
+        }.visit_expr(body.value);
+    }
+}
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 4e05a56d..a15ee821 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -1968,6 +1968,36 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "pallet-satirating-arithmetic-vulnerable-1"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-satirating-arithmetic-vulnerable-2"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "parity-bip39"
 version = "2.0.1"
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
index 73ea3b48..d29f03c1 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
@@ -15,7 +15,6 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { workspace = true }
 log = { workspace = true }
 scale-info = { features = ["derive"], workspace = true }
-frame-benchmarking = { optional = true, workspace = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 pallet-balances = { workspace = true }
@@ -29,7 +28,6 @@ sp-core = { workspace = true }
 default = ["std"]
 std = [
 	"codec/std",
-	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
index 0094aebb..5e26d6cf 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
@@ -141,12 +141,6 @@ pub mod pallet {
     #[pallet::storage]
     pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
 
-    #[pallet::storage]
-    pub(super) type Bar<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, T::Balance>;
-
-    #[pallet::storage]
-    pub(super) type Foo<T: Config> = StorageValue<_, T::Balance, ValueQuery>;
-
     #[pallet::storage]
     pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
 
@@ -154,38 +148,16 @@ pub mod pallet {
     #[derive(frame_support::DefaultNoBound)]
     pub struct GenesisConfig<T: Config> {
         pub dummy: T::Balance,
-        pub bar: Vec<(T::AccountId, T::Balance)>,
-        pub foo: T::Balance,
     }
 
     #[pallet::genesis_build]
     impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
         fn build(&self) {
             <Dummy<T>>::put(self.dummy);
-            for (a, b) in &self.bar {
-                <Bar<T>>::insert(a, b);
-            }
-            <Foo<T>>::put(self.foo);
         }
     }
 }
 
-impl<T: Config> Pallet<T> {
-    #[allow(dead_code)]
-    fn accumulate_foo(origin: T::RuntimeOrigin, increase_by: T::Balance) -> DispatchResult {
-        let _sender = ensure_signed(origin)?;
-
-        let prev = Foo::<T>::get();
-        let result = Foo::<T>::mutate(|x| {
-            *x = x.saturating_add(increase_by);
-            *x
-        });
-        assert!(prev + increase_by == result);
-
-        Ok(())
-    }
-}
-
 #[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
 #[scale_info(skip_type_params(T))]
 pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
index c424e185..3daa0b90 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
@@ -65,8 +65,6 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
         balances: Default::default(),
         example: pallet_example_basic::GenesisConfig {
             dummy: 42,
-            bar: alloc::vec![(1, 2), (2, 3)],
-            foo: 24,
         },
     }
     .build_storage()
@@ -90,15 +88,6 @@ fn it_works_for_optional_value() {
     });
 }
 
-#[test]
-fn it_works_for_default_value() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(Foo::<Test>::get(), 24);
-        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
-        assert_eq!(Foo::<Test>::get(), 25);
-    });
-}
-
 #[test]
 fn set_dummy_works() {
     new_test_ext().execute_with(|| {
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
index a08e6401..b912217f 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
@@ -15,7 +15,6 @@ targets = ["x86_64-unknown-linux-gnu"]
 codec = { workspace = true }
 log = { workspace = true }
 scale-info = { features = ["derive"], workspace = true }
-frame-benchmarking = { optional = true, workspace = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 pallet-balances = { workspace = true }
@@ -29,7 +28,6 @@ sp-core = { workspace = true }
 default = ["std"]
 std = [
 	"codec/std",
-	"frame-benchmarking?/std",
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",

From 2819a5cf3748c70e562c7ad4968a7e01e97f1d9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?= <helios.vmg@gmail.com>
Date: Fri, 6 Dec 2024 11:19:05 -0300
Subject: [PATCH 17/30] Regenerate Cargo.lock.

---
 detectors/substrate-pallets/Cargo.lock | 51 +++++++++++++-------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index a811b6d0..8c1544a1 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -14,9 +14,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.93"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7"
 
 [[package]]
 name = "arrayvec"
@@ -45,9 +45,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "camino"
@@ -60,9 +60,9 @@ dependencies = [
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
 dependencies = [
  "serde",
 ]
@@ -173,9 +173,9 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "hashbrown"
-version = "0.15.1"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 
 [[package]]
 name = "if_chain"
@@ -185,9 +185,9 @@ checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
 
 [[package]]
 name = "indexmap"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
+checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -236,9 +236,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.11"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
 
 [[package]]
 name = "macros"
@@ -263,9 +263,9 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -287,9 +287,9 @@ checksum = "5be1bdc7edf596692617627bbfeaba522131b18e06ca4df2b6b689e3c5d5ce84"
 
 [[package]]
 name = "rustc_apfloat"
-version = "0.2.1+llvm-462a31f5a5ab"
+version = "0.2.2+llvm-462a31f5a5ab"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "886d94c63c812a8037c4faca2607453a0fa4cf82f734665266876b022244543f"
+checksum = "121e2195ff969977a4e2b5c9965ea867fce7e4cb5aee5b09dee698a7932d574f"
 dependencies = [
  "bitflags",
  "smallvec",
@@ -307,9 +307,6 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
-[[package]]
-]
-
 [[package]]
 name = "saturating-arithmetic"
 version = "0.1.0"
@@ -318,6 +315,9 @@ dependencies = [
  "common",
  "dylint_internal",
  "dylint_linting",
+]
+
+[[package]]
 name = "semver"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -348,11 +348,12 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.133"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
@@ -374,9 +375,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -484,9 +485,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
 
 [[package]]
 name = "unsafe-expect"

From db50110977bf642eba8664dd010ec882feec8aed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?= <helios.vmg@gmail.com>
Date: Fri, 6 Dec 2024 11:26:33 -0300
Subject: [PATCH 18/30] Detector works.

---
 .../saturating-arithmetic/src/lib.rs          | 35 ++++++++++---------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
index 727e083d..4ad2000e 100644
--- a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -4,39 +4,33 @@ extern crate rustc_ast;
 extern crate rustc_hir;
 extern crate rustc_span;
 extern crate rustc_middle;
+extern crate rustc_errors;
 
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use common::{
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
 };
 use rustc_hir::{
     def_id::LocalDefId,
-    intravisit::{walk_expr, walk_fn, FnKind, Visitor},
-    Body, BodyId, Expr, ExprKind, FnDecl, Mod, HirId,
+    intravisit::{walk_expr, FnKind, Visitor},
+    Body, Expr, FnDecl,
 };
-use rustc_ast::{
-    NodeId,
-};
-use rustc_middle::middle::privacy::Level;
+use rustc_errors::Applicability;
 use rustc_lint::{
-    EarlyContext,
-    EarlyLintPass,
     LateContext,
     LateLintPass,
 };
 use rustc_span::Span;
 use common::analysis::{
     get_node_type,
-    is_macro_expansion,
     decomposers::*,
 };
 use std::{
-    collections::HashSet, ops::Deref, sync::{Arc, Mutex, MutexGuard}
+    collections::HashSet, ops::Deref, sync::{Arc, Mutex}
 };
 
 const LINT_MESSAGE: &str = "Saturating arithmetic may silently generate incorrect results.";
-const LINT_HELP: &str = "Instead of overflowing, saturating arithmetic clamps the result to the representation limit for the data type. Consider checked arithmetic instead.";
 const RELEVANT_FUNCTIONS: [&str; 6] = [
     "saturating_add",
     "saturating_add_signed",
@@ -124,14 +118,23 @@ static GLOBAL_STATE: Mutex<Option<Arc<Mutex<GlobalState>>>> = Mutex::new(None);
 
 fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()>{
     let (method_name, receiver, _args, _span) = expr_to_method_call(&expr.kind)?;
-    if !GlobalState::method_is_relevant(method_name.ident.name.as_str()){
+    let method_name_str = method_name.ident.name.as_str();
+    if !GlobalState::method_is_relevant(method_name_str){
         None?;        
     }
     let node_type = get_node_type(cx, &receiver.hir_id);
     if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)){
         None?;
     }
-    
+    span_lint_and_sugg(
+        cx,
+        SATURATING_ARITHMETIC,
+        method_name.ident.span,
+        LINT_MESSAGE,
+        "Instead of overflowing, saturating arithmetic clamps the result to the representation limit for the data type. Consider checked arithmetic instead",
+        format!("checked_{}", &method_name_str[11..]),
+        Applicability::MaybeIncorrect,
+    );
     None
 }
 
@@ -159,10 +162,10 @@ impl<'tcx> LateLintPass<'tcx> for SaturatingArithmetic {
         &mut self,
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         _: Span,
-        ldid: LocalDefId,
+        _: LocalDefId,
     ){
         if GlobalState::function_is_ignored(&ident(&kind)){
             return;

From c85938b7d7f056fd6c72ff00721be6f6c34d1643 Mon Sep 17 00:00:00 2001
From: fpereira24 <francisco.pereira@coinfabrik.com>
Date: Fri, 6 Dec 2024 11:46:05 -0300
Subject: [PATCH 19/30] add avoid-debug-info detector

---
 detectors/substrate-pallets/Cargo.lock        |   9 ++
 .../avoid-debug-info/Cargo.toml               |  15 +++
 .../avoid-debug-info/src/lib.rs               | 101 ++++++++++++++++++
 test-cases/substrate-pallets/Cargo.lock       |  30 ++++++
 .../remediated/remediated-1/Cargo.toml        |  34 ++++++
 .../remediated/remediated-1/src/lib.rs        |  99 +++++++++++++++++
 .../remediated/remediated-1/src/weights.rs    |  34 ++++++
 .../vulnerable/vulnerable-1/Cargo.toml        |  34 ++++++
 .../vulnerable/vulnerable-1/src/lib.rs        |  87 +++++++++++++++
 .../vulnerable/vulnerable-1/src/weights.rs    |  34 ++++++
 10 files changed, 477 insertions(+)
 create mode 100644 detectors/substrate-pallets/avoid-debug-info/Cargo.toml
 create mode 100644 detectors/substrate-pallets/avoid-debug-info/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/weights.rs

diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index b98c6ba7..1ec4e86d 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -86,6 +86,15 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
+[[package]]
+name = "avoid-debug-info"
+version = "0.1.0"
+dependencies = [
+ "clippy_utils",
+ "common",
+ "dylint_linting",
+]
+
 [[package]]
 name = "avoid-dispatcherror-other"
 version = "0.1.0"
diff --git a/detectors/substrate-pallets/avoid-debug-info/Cargo.toml b/detectors/substrate-pallets/avoid-debug-info/Cargo.toml
new file mode 100644
index 00000000..768c2f84
--- /dev/null
+++ b/detectors/substrate-pallets/avoid-debug-info/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+edition = "2021"
+name = "avoid-debug-info"
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+clippy_utils = { workspace = true }
+common = { workspace = true }
+dylint_linting = { workspace = true }
+
+[package.metadata.rust-analyzer]
+rustc_private = true
diff --git a/detectors/substrate-pallets/avoid-debug-info/src/lib.rs b/detectors/substrate-pallets/avoid-debug-info/src/lib.rs
new file mode 100644
index 00000000..3454f692
--- /dev/null
+++ b/detectors/substrate-pallets/avoid-debug-info/src/lib.rs
@@ -0,0 +1,101 @@
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_span;
+
+use clippy_utils::{diagnostics::span_lint_and_help, sym};
+use common::{
+    declarations::{Severity, VulnerabilityClass},
+    macros::expose_lint_info,
+};
+use rustc_ast::{tokenstream::TokenTree, AttrArgs, AttrKind, Item, MacCall};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_span::{sym, Span};
+
+const LINT_MESSAGE: &str = "The debug! or info! macros are used in the code. \
+    Consider emitting events instead, or removing them.";
+const HELP_MESSAGE: &str =
+    "Consider using emit! to emit events, or removing the debug! and info! macros.";
+
+#[expose_lint_info]
+pub static AVOID_DEBUG_INFO_INFO: LintInfo = LintInfo {
+    name: env!("CARGO_PKG_NAME"),
+    short_message: LINT_MESSAGE,
+    long_message:
+    "The use of debugging macros, such as debug!() and info!(), has been detected in the contract code. \
+    While useful during development and testing, these macros are not recommended for production. \
+    Instead, consider emitting structured events with emit! to log relevant data more efficiently \
+    and reduce unnecessary gas costs.",
+    severity: Severity::Minor,
+    help: "https://coinfabrik.github.io/scout/docs/detectors/avoid-debug-info",
+    vulnerability_class: VulnerabilityClass::BestPractices,
+};
+
+dylint_linting::impl_pre_expansion_lint! {
+    pub AVOID_DEBUG_INFO,
+    Warn,
+    LINT_MESSAGE,
+    AvoidDebugInfo::default()
+}
+
+#[derive(Default)]
+pub struct AvoidDebugInfo {
+    test_spans: Vec<Span>,
+}
+
+impl AvoidDebugInfo {
+    fn is_within_test(&self, span: Span) -> bool {
+        self.test_spans
+            .iter()
+            .any(|test_span| test_span.contains(span))
+    }
+
+    fn is_test_token_present(args: &AttrArgs) -> bool {
+        matches!(args, AttrArgs::Delimited(delim_args) if delim_args
+            .tokens
+            .trees()
+            .any(|tree| matches!(tree, TokenTree::Token(token, _) if token.is_ident_named(sym::test))))
+    }
+
+    fn is_test_item(item: &Item) -> bool {
+        item.attrs.iter().any(|attr| {
+            attr.has_name(sym::test)
+                || (attr.has_name(sym::cfg)
+                    && attr.meta_item_list().map_or(false, |list| {
+                        list.iter().any(|item| item.has_name(sym::test))
+                    }))
+                || matches!(
+                    &attr.kind,
+                    AttrKind::Normal(normal) if Self::is_test_token_present(&normal.item.args)
+                )
+        })
+    }
+
+}
+
+impl EarlyLintPass for AvoidDebugInfo {
+    fn check_item(&mut self, _: &EarlyContext<'_>, item: &rustc_ast::Item) {
+        if Self::is_test_item(item) {
+            self.test_spans.push(item.span);
+        }
+    }
+    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
+        if (mac.path != sym::debug) && (mac.path != sym!(info)){
+            return;
+        }
+
+        // Early return if within a test function
+        if self.is_within_test(mac.span()) {
+            return;
+        }
+
+        span_lint_and_help(
+            cx,
+            AVOID_DEBUG_INFO,
+            mac.span(),
+            LINT_MESSAGE,
+            None,
+            HELP_MESSAGE,
+        );
+    }
+}
\ No newline at end of file
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 4e05a56d..ba2206e8 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -288,6 +288,36 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
+[[package]]
+name = "avoid-debug-info-remediated-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "avoid-debug-info-vulnerable-1"
+version = "0.1.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "avoid-panic-error-remediated-1"
 version = "0.1.0"
diff --git a/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/Cargo.toml b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/Cargo.toml
new file mode 100644
index 00000000..8733118f
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "avoid-debug-info-remediated-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-support/std",
+    "frame-system/std",
+    "log/std",
+    "pallet-balances/std",
+    "scale-info/std",
+    "sp-core/std",
+    "sp-io/std",
+    "sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
new file mode 100644
index 00000000..889d8bb3
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
@@ -0,0 +1,99 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub use pallet::*;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn value)]
+    pub type Value<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::call(weight = <T as Config>::WeightInfo)]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn unsafe_check_value(origin: OriginFor<T>, threshold: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            let stored_value = Value::<T>::get().unwrap_or_default();
+            if stored_value < threshold {
+                Self::deposit_event(Event::ValueTooLow {
+                    who: who.clone(),
+                    stored_value,
+                    threshold,
+                });
+                return Err(Error::<T>::ValueTooLow.into());
+            }
+            Self::deposit_event(Event::ValueChecked {
+                who,
+                value: stored_value,
+            });
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        pub fn set_value(origin: OriginFor<T>, new_value: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            let old_value = Value::<T>::get().unwrap_or_default();
+            Value::<T>::put(new_value);
+            Self::deposit_event(Event::ValueSet {
+                who: who.clone(),
+                value: new_value,
+            });
+            Self::deposit_event(Event::ValueUpdated {
+                who,
+                old_value,
+                new_value,
+            });
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        ValueChecked { who: T::AccountId, value: u32 },
+        ValueSet { who: T::AccountId, value: u32 },
+        ValueTooLow { who: T::AccountId, stored_value: u32, threshold: u32 },
+        ValueUpdated { who: T::AccountId, old_value: u32, new_value: u32 },
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        ValueTooLow,
+    }
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub initial_value: Option<u32>,
+        #[serde(skip)]
+        pub _phantom: PhantomData<T>,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            if let Some(value) = self.initial_value {
+                Value::<T>::put(value);
+            }
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/weights.rs b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/weights.rs
new file mode 100644
index 00000000..5aa34c97
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/weights.rs
@@ -0,0 +1,34 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn unsafe_check_value() -> Weight;
+	fn set_value() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn unsafe_check_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	fn set_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads_writes(1_u64, 1_u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn unsafe_check_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	fn set_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads_writes(1_u64, 1_u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/Cargo.toml
new file mode 100644
index 00000000..e4089f58
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+edition = "2021"
+name = "avoid-debug-info-vulnerable-1"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+pallet-balances = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-support/std",
+    "frame-system/std",
+    "log/std",
+    "pallet-balances/std",
+    "scale-info/std",
+    "sp-core/std",
+    "sp-io/std",
+    "sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
new file mode 100644
index 00000000..db723fb9
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
@@ -0,0 +1,87 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+pub use pallet::*;
+use log::{debug, info};
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::{pallet_prelude::*, traits::BuildGenesisConfig};
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::storage]
+    #[pallet::getter(fn value)]
+    pub type Value<T: Config> = StorageValue<_, u32>;
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn unsafe_check_value(origin: OriginFor<T>, threshold: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            let stored_value = Value::<T>::get().unwrap_or_default();
+
+            debug!("Stored value: {:?}, Threshold: {:?}", stored_value, threshold);
+            info!("Consider providing a threshold lower than the actual stored value");
+
+            Self::deposit_event(Event::ValueChecked {
+                who,
+                value: stored_value,
+            });
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        pub fn set_value(origin: OriginFor<T>, new_value: u32) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+            Value::<T>::put(new_value);
+            Self::deposit_event(Event::ValueSet {
+                who,
+                value: new_value,
+            });
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        ValueChecked { who: T::AccountId, value: u32 },
+        ValueSet { who: T::AccountId, value: u32 },
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        ValueTooLow,
+    }
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound, Debug)]
+    pub struct GenesisConfig<T: Config> {
+        pub initial_value: Option<u32>,
+        #[serde(skip)]
+        pub _phantom: PhantomData<T>,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            if let Some(value) = self.initial_value {
+                Value::<T>::put(value);
+            }
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/weights.rs b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/weights.rs
new file mode 100644
index 00000000..5aa34c97
--- /dev/null
+++ b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/weights.rs
@@ -0,0 +1,34 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn unsafe_check_value() -> Weight;
+	fn set_value() -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn unsafe_check_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	fn set_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads_writes(1_u64, 1_u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn unsafe_check_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	fn set_value() -> Weight {
+		Weight::from_parts(10_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads_writes(1_u64, 1_u64))
+	}
+}

From 027762f7bee294d01811cf92a4982de0016e7e0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?= <helios.vmg@gmail.com>
Date: Fri, 6 Dec 2024 11:55:06 -0300
Subject: [PATCH 20/30] Added test cases.

---
 test-cases/substrate-pallets/Cargo.lock       |  30 +++
 .../vulnerable/vulnerable-1/src/lib.rs        |   1 -
 .../vulnerable/vulnerable-2/src/lib.rs        |   1 -
 .../vulnerable/vulnerable-2/src/weights.rs    |   6 +-
 .../vulnerable/vulnerable-3/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-3/src/lib.rs        | 218 ++++++++++++++++++
 .../vulnerable/vulnerable-3/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-3/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-4/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-4/src/lib.rs        | 218 ++++++++++++++++++
 .../vulnerable/vulnerable-4/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-4/src/weights.rs    |  46 ++++
 12 files changed, 923 insertions(+), 5 deletions(-)
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs

diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 439ec4eb..ebd2a9ee 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -2028,6 +2028,36 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "pallet-satirating-arithmetic-vulnerable-3"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-satirating-arithmetic-vulnerable-4"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "parity-bip39"
 version = "2.0.1"
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
index 5e26d6cf..b44bfb1b 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
@@ -2,7 +2,6 @@
 
 extern crate alloc;
 
-use alloc::vec::Vec;
 use codec::{Decode, Encode};
 use core::marker::PhantomData;
 use frame_support::{
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
index 706b2f77..394722cf 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
@@ -2,7 +2,6 @@
 
 extern crate alloc;
 
-use alloc::vec::Vec;
 use codec::{Decode, Encode};
 use core::marker::PhantomData;
 use frame_support::{
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs
index 43d6814b..407d3884 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/weights.rs
@@ -7,7 +7,7 @@ use core::marker::PhantomData;
 
 pub trait WeightInfo {
 	fn set_dummy_benchmark() -> Weight;
-	fn accumulate_dummy() -> Weight;
+	fn multiply_dummy() -> Weight;
 	fn sort_vector(x: u32, ) -> Weight;
 }
 
@@ -17,7 +17,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		Weight::from_parts(19_000_000_u64, 0)
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	fn accumulate_dummy() -> Weight {
+	fn multiply_dummy() -> Weight {
 		Weight::from_parts(18_000_000_u64, 0)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
@@ -34,7 +34,7 @@ impl WeightInfo for () {
 		Weight::from_parts(19_000_000_u64, 0)
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	fn accumulate_dummy() -> Weight {
+	fn multiply_dummy() -> Weight {
 		Weight::from_parts(18_000_000_u64, 0)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
new file mode 100644
index 00000000..88b0951b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-satirating-arithmetic-vulnerable-3"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
new file mode 100644
index 00000000..c8bdbe78
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
@@ -0,0 +1,218 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, decrease_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.map_or(decrease_by, |d| d.saturating_sub(decrease_by));
+                *dummy = Some(new_dummy);
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: decrease_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
new file mode 100644
index 00000000..0b8db734
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-satirating-arithmetic-vulnerable-4"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
new file mode 100644
index 00000000..bafe0d2c
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
@@ -0,0 +1,218 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn divide_dummy(origin: OriginFor<T>, divide_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.map_or(divide_by, |d| d.saturating_div(divide_by));
+                *dummy = Some(new_dummy);
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: divide_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs
new file mode 100644
index 00000000..fd42f495
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn divide_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn divide_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn divide_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}

From 758dd149572994fa99827d70df95c6f6ef60bc64 Mon Sep 17 00:00:00 2001
From: fpereira24 <francisco.pereira@coinfabrik.com>
Date: Fri, 6 Dec 2024 13:07:33 -0300
Subject: [PATCH 21/30] fix errors

---
 detectors/substrate-pallets/Cargo.lock | 26 +++++---------------------
 1 file changed, 5 insertions(+), 21 deletions(-)

diff --git a/detectors/substrate-pallets/Cargo.lock b/detectors/substrate-pallets/Cargo.lock
index 843719ff..daab9275 100644
--- a/detectors/substrate-pallets/Cargo.lock
+++ b/detectors/substrate-pallets/Cargo.lock
@@ -23,30 +23,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
-name = "async-compression"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cb8f1d480b0ea3783ab015936d2a55c87e219676f0c0b7dec61494043f21857"
+name = "avoid-debug-info"
+version = "0.1.0"
 dependencies = [
- "flate2",
- "futures-core",
- "memchr",
- "pin-project-lite",
- "tokio",
+ "clippy_utils",
+ "common",
+ "dylint_linting",
 ]
 
-[[package]]
-name = "atomic-waker"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
-
-[[package]]
-name = "autocfg"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
-
 [[package]]
 name = "avoid-dispatcherror-other"
 version = "0.1.0"

From d549706bdaf9b6dacd9ca222a6936840366b77b4 Mon Sep 17 00:00:00 2001
From: fpereira24 <francisco.pereira@coinfabrik.com>
Date: Fri, 6 Dec 2024 13:15:47 -0300
Subject: [PATCH 22/30] fix errors

---
 .../avoid-debug-info/src/lib.rs               |  5 ++---
 .../remediated/remediated-1/src/lib.rs        | 22 +++++++++++++++----
 .../vulnerable/vulnerable-1/src/lib.rs        |  7 ++++--
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/detectors/substrate-pallets/avoid-debug-info/src/lib.rs b/detectors/substrate-pallets/avoid-debug-info/src/lib.rs
index 3454f692..fb03c319 100644
--- a/detectors/substrate-pallets/avoid-debug-info/src/lib.rs
+++ b/detectors/substrate-pallets/avoid-debug-info/src/lib.rs
@@ -70,7 +70,6 @@ impl AvoidDebugInfo {
                 )
         })
     }
-
 }
 
 impl EarlyLintPass for AvoidDebugInfo {
@@ -80,7 +79,7 @@ impl EarlyLintPass for AvoidDebugInfo {
         }
     }
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        if (mac.path != sym::debug) && (mac.path != sym!(info)){
+        if (mac.path != sym::debug) && (mac.path != sym!(info)) {
             return;
         }
 
@@ -98,4 +97,4 @@ impl EarlyLintPass for AvoidDebugInfo {
             HELP_MESSAGE,
         );
     }
-}
\ No newline at end of file
+}
diff --git a/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
index 889d8bb3..9304e636 100644
--- a/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
+++ b/test-cases/substrate-pallets/avoid-debug-info/remediated/remediated-1/src/lib.rs
@@ -69,10 +69,24 @@ pub mod pallet {
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
-        ValueChecked { who: T::AccountId, value: u32 },
-        ValueSet { who: T::AccountId, value: u32 },
-        ValueTooLow { who: T::AccountId, stored_value: u32, threshold: u32 },
-        ValueUpdated { who: T::AccountId, old_value: u32, new_value: u32 },
+        ValueChecked {
+            who: T::AccountId,
+            value: u32,
+        },
+        ValueSet {
+            who: T::AccountId,
+            value: u32,
+        },
+        ValueTooLow {
+            who: T::AccountId,
+            stored_value: u32,
+            threshold: u32,
+        },
+        ValueUpdated {
+            who: T::AccountId,
+            old_value: u32,
+            new_value: u32,
+        },
     }
 
     #[pallet::error]
diff --git a/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
index db723fb9..6d1e596b 100644
--- a/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/avoid-debug-info/vulnerable/vulnerable-1/src/lib.rs
@@ -2,8 +2,8 @@
 
 extern crate alloc;
 
-pub use pallet::*;
 use log::{debug, info};
+pub use pallet::*;
 pub mod weights;
 pub use weights::*;
 
@@ -34,7 +34,10 @@ pub mod pallet {
 
             let stored_value = Value::<T>::get().unwrap_or_default();
 
-            debug!("Stored value: {:?}, Threshold: {:?}", stored_value, threshold);
+            debug!(
+                "Stored value: {:?}, Threshold: {:?}",
+                stored_value, threshold
+            );
             info!("Consider providing a threshold lower than the actual stored value");
 
             Self::deposit_event(Event::ValueChecked {

From 40984ca1863e1a800ffc77bdf092df25ac3c2523 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 14:21:07 -0300
Subject: [PATCH 23/30] Finished vulnerable test cases.

---
 .../saturating-arithmetic/src/lib.rs          |  69 ++++--
 test-cases/substrate-pallets/Cargo.lock       | 100 +++++++-
 .../vulnerable/vulnerable-1/Cargo.toml        |   2 +-
 .../vulnerable/vulnerable-10/Cargo.toml       |  39 ++++
 .../vulnerable/vulnerable-10/src/lib.rs       | 219 ++++++++++++++++++
 .../vulnerable/vulnerable-10/src/tests.rs     | 142 ++++++++++++
 .../vulnerable/vulnerable-10/src/weights.rs   |  46 ++++
 .../vulnerable/vulnerable-2/Cargo.toml        |   2 +-
 .../vulnerable/vulnerable-3/Cargo.toml        |   2 +-
 .../vulnerable/vulnerable-3/src/lib.rs        |   3 +-
 .../vulnerable/vulnerable-4/Cargo.toml        |   2 +-
 .../vulnerable/vulnerable-4/src/lib.rs        |  13 +-
 .../vulnerable/vulnerable-4/src/weights.rs    |   6 +-
 .../vulnerable/vulnerable-5/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-5/src/lib.rs        | 215 +++++++++++++++++
 .../vulnerable/vulnerable-5/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-5/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-6/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-6/src/lib.rs        | 215 +++++++++++++++++
 .../vulnerable/vulnerable-6/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-6/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-7/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-7/src/lib.rs        | 215 +++++++++++++++++
 .../vulnerable/vulnerable-7/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-7/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-8/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-8/src/lib.rs        | 215 +++++++++++++++++
 .../vulnerable/vulnerable-8/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-8/src/weights.rs    |  46 ++++
 .../vulnerable/vulnerable-9/Cargo.toml        |  39 ++++
 .../vulnerable/vulnerable-9/src/lib.rs        | 219 ++++++++++++++++++
 .../vulnerable/vulnerable-9/src/tests.rs      | 142 ++++++++++++
 .../vulnerable/vulnerable-9/src/weights.rs    |  46 ++++
 33 files changed, 2819 insertions(+), 40 deletions(-)
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/weights.rs

diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
index 4ad2000e..7095dc67 100644
--- a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -6,7 +6,10 @@ extern crate rustc_span;
 extern crate rustc_middle;
 extern crate rustc_errors;
 
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{
+    span_lint_and_sugg,
+    span_lint_and_help,
+};
 use common::{
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
@@ -27,17 +30,33 @@ use common::analysis::{
     decomposers::*,
 };
 use std::{
-    collections::HashSet, ops::Deref, sync::{Arc, Mutex}
+    collections::{
+        HashSet,
+        HashMap,
+    },
+    ops::Deref,
+    sync::{
+        Arc,
+        Mutex,
+    },
 };
 
 const LINT_MESSAGE: &str = "Saturating arithmetic may silently generate incorrect results.";
-const RELEVANT_FUNCTIONS: [&str; 6] = [
-    "saturating_add",
-    "saturating_add_signed",
-    "saturating_sub",
-    "saturating_mul",
-    "saturating_div",
-    "saturating_pow",
+const F: bool = false;
+const T: bool = true;
+const RELEVANT_FUNCTIONS: [(&str, bool, bool); 12] = [
+    ("saturating_add",        T, T),
+    ("saturating_add_signed", T, F),
+    ("saturating_sub",        T, T),
+    ("saturating_mul",        T, T),
+    ("saturating_div",        T, F),
+    ("saturating_pow",        T, T),
+    ("saturating_less_one",   F, T),
+    ("saturating_plus_one",   F, T),
+    ("saturating_inc",        F, T),
+    ("saturating_dec",        F, T),
+    ("saturating_accrue",     F, T),
+    ("saturating_reduce",     F, T),
 ];
 const IGNORED_FUNCTIONS: [&str; 1] = [
     "size_hint",
@@ -62,16 +81,34 @@ dylint_linting::declare_late_lint! {
     LINT_MESSAGE
 }
 
+#[derive(Clone)]
+struct FunctionAvailability{
+    pub available_on_std: bool,
+    pub available_on_substrate: bool,
+}
+
+impl FunctionAvailability{
+    pub fn new(available_on_std: bool, available_on_substrate: bool) -> Self{
+        Self{
+            available_on_std,
+            available_on_substrate,
+        }
+    }
+}
+
 struct GlobalState{
-    relevant_functions: HashSet<String>,
+    relevant_functions: HashMap<String, FunctionAvailability>,
     ignored_functions: HashSet<String>,
     ignored_types: HashSet<String>,
 }
 
 impl GlobalState{
     pub fn new() -> Self{
-        GlobalState{
-            relevant_functions: Self::to_hash_set(&RELEVANT_FUNCTIONS[..]),
+        Self{
+            relevant_functions: RELEVANT_FUNCTIONS
+                .iter()
+                .map(|(x, y, z)| (x.to_string(), FunctionAvailability::new(*y, *z)))
+                .collect(),
             ignored_functions: Self::to_hash_set(&IGNORED_FUNCTIONS[..]),
             ignored_types: Self::to_hash_set(&IGNORED_TYPES[..]),
         }
@@ -93,10 +130,10 @@ impl GlobalState{
             Some(p) => p.clone(),
         }
     }
-    pub fn method_is_relevant(method_name: &str) -> bool{
+    pub fn method_is_relevant(method_name: &str) -> Option<FunctionAvailability>{
         let gs = Self::get_state();
         let lock = gs.lock().unwrap();
-        lock.relevant_functions.contains(method_name)
+        Some(lock.relevant_functions.get(method_name)?.clone())
     }
     pub fn type_is_ignored(name: &Option<String>) -> bool{
         if let Some(name) = name{
@@ -119,9 +156,7 @@ static GLOBAL_STATE: Mutex<Option<Arc<Mutex<GlobalState>>>> = Mutex::new(None);
 fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()>{
     let (method_name, receiver, _args, _span) = expr_to_method_call(&expr.kind)?;
     let method_name_str = method_name.ident.name.as_str();
-    if !GlobalState::method_is_relevant(method_name_str){
-        None?;        
-    }
+    let _availability = GlobalState::method_is_relevant(method_name_str)?;
     let node_type = get_node_type(cx, &receiver.hir_id);
     if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)){
         None?;
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index ebd2a9ee..7532dab4 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "Inflector"
@@ -1999,7 +1999,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "pallet-satirating-arithmetic-vulnerable-1"
+name = "pallet-saturating-arithmetic-vulnerable-1"
 version = "27.0.0"
 dependencies = [
  "frame-support",
@@ -2014,7 +2014,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "pallet-satirating-arithmetic-vulnerable-2"
+name = "pallet-saturating-arithmetic-vulnerable-10"
 version = "27.0.0"
 dependencies = [
  "frame-support",
@@ -2029,7 +2029,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "pallet-satirating-arithmetic-vulnerable-3"
+name = "pallet-saturating-arithmetic-vulnerable-2"
 version = "27.0.0"
 dependencies = [
  "frame-support",
@@ -2044,7 +2044,97 @@ dependencies = [
 ]
 
 [[package]]
-name = "pallet-satirating-arithmetic-vulnerable-4"
+name = "pallet-saturating-arithmetic-vulnerable-3"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-4"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-5"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-6"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-7"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-8"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-vulnerable-9"
 version = "27.0.0"
 dependencies = [
  "frame-support",
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
index d29f03c1..d6a8bc39 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "pallet-satirating-arithmetic-vulnerable-1"
+name = "pallet-saturating-arithmetic-vulnerable-1"
 version = "27.0.0"
 authors.workspace = true
 edition.workspace = true
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/Cargo.toml
new file mode 100644
index 00000000..ec1c6625
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-10"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
new file mode 100644
index 00000000..3a4ff9c8
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
@@ -0,0 +1,219 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    x.saturating_reduce(increase_by);
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
index b912217f..e067c2c0 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "pallet-satirating-arithmetic-vulnerable-2"
+name = "pallet-saturating-arithmetic-vulnerable-2"
 version = "27.0.0"
 authors.workspace = true
 edition.workspace = true
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
index 88b0951b..31d1ed4f 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "pallet-satirating-arithmetic-vulnerable-3"
+name = "pallet-saturating-arithmetic-vulnerable-3"
 version = "27.0.0"
 authors.workspace = true
 edition.workspace = true
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
index c8bdbe78..13ce0b47 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
@@ -93,8 +93,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                let new_dummy = dummy.map_or(decrease_by, |d| d.saturating_sub(decrease_by));
-                *dummy = Some(new_dummy);
+                *dummy = dummy.and_then(|d| Some(d.saturating_sub(decrease_by)));
             });
 
             Self::deposit_event(Event::AccumulateDummy {
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
index 0b8db734..f14f7649 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "pallet-satirating-arithmetic-vulnerable-4"
+name = "pallet-saturating-arithmetic-vulnerable-4"
 version = "27.0.0"
 authors.workspace = true
 edition.workspace = true
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
index bafe0d2c..d222c030 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
@@ -89,17 +89,14 @@ pub mod pallet {
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
-        pub fn divide_dummy(origin: OriginFor<T>, divide_by: T::Balance) -> DispatchResult {
+        pub fn cube_dummy(origin: OriginFor<T>) -> DispatchResult {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                let new_dummy = dummy.map_or(divide_by, |d| d.saturating_div(divide_by));
-                *dummy = Some(new_dummy);
+                *dummy = dummy.and_then(|d| Some(d.saturating_pow(3_usize)));
             });
 
-            Self::deposit_event(Event::AccumulateDummy {
-                balance: divide_by,
-            });
+            Self::deposit_event(Event::AccumulateDummy);
 
             Ok(())
         }
@@ -125,9 +122,7 @@ pub mod pallet {
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
     pub enum Event<T: Config> {
-        AccumulateDummy {
-            balance: BalanceOf<T>,
-        },
+        AccumulateDummy,
         SetDummy {
             balance: BalanceOf<T>,
         },
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs
index fd42f495..86bd1941 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/weights.rs
@@ -7,7 +7,7 @@ use core::marker::PhantomData;
 
 pub trait WeightInfo {
 	fn set_dummy_benchmark() -> Weight;
-	fn divide_dummy() -> Weight;
+	fn cube_dummy() -> Weight;
 	fn sort_vector(x: u32, ) -> Weight;
 }
 
@@ -17,7 +17,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		Weight::from_parts(19_000_000_u64, 0)
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	fn divide_dummy() -> Weight {
+	fn cube_dummy() -> Weight {
 		Weight::from_parts(18_000_000_u64, 0)
 			.saturating_add(T::DbWeight::get().reads(1_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
@@ -34,7 +34,7 @@ impl WeightInfo for () {
 		Weight::from_parts(19_000_000_u64, 0)
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	fn divide_dummy() -> Weight {
+	fn cube_dummy() -> Weight {
 		Weight::from_parts(18_000_000_u64, 0)
 			.saturating_add(RocksDbWeight::get().reads(1_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/Cargo.toml
new file mode 100644
index 00000000..fd8e22f1
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-5"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
new file mode 100644
index 00000000..56888396
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
@@ -0,0 +1,215 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    *dummy = Some(x.saturating_less_one());
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/Cargo.toml
new file mode 100644
index 00000000..2c11ad19
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-6"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
new file mode 100644
index 00000000..a188222f
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
@@ -0,0 +1,215 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    x.saturating_dec();
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/Cargo.toml
new file mode 100644
index 00000000..f3430d82
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-7"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
new file mode 100644
index 00000000..b553c160
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
@@ -0,0 +1,215 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    *dummy = Some(x.saturating_plus_one());
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/Cargo.toml
new file mode 100644
index 00000000..97086f4d
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-8"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
new file mode 100644
index 00000000..54bb6a9a
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
@@ -0,0 +1,215 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    x.saturating_inc();
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/Cargo.toml
new file mode 100644
index 00000000..a071c159
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-vulnerable-9"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
new file mode 100644
index 00000000..9fa74293
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
@@ -0,0 +1,219 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    x.saturating_accrue(increase_by);
+                }
+            });
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}

From 709e86d430538a63406e6faa25af11b85c7c70b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 15:07:55 -0300
Subject: [PATCH 24/30] Added remediated test cases.

---
 .../saturating-arithmetic/src/lib.rs          |  70 ++++--
 test-cases/substrate-pallets/Cargo.lock       | 150 +++++++++++
 .../remediated/remediated-1/Cargo.toml        |  39 +++
 .../remediated/remediated-1/src/lib.rs        | 236 ++++++++++++++++++
 .../remediated/remediated-1/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-1/src/weights.rs    |  46 ++++
 .../remediated/remediated-10/Cargo.toml       |  39 +++
 .../remediated/remediated-10/src/lib.rs       | 232 +++++++++++++++++
 .../remediated/remediated-10/src/tests.rs     | 142 +++++++++++
 .../remediated/remediated-10/src/weights.rs   |  46 ++++
 .../remediated/remediated-2/Cargo.toml        |  39 +++
 .../remediated/remediated-2/src/lib.rs        | 234 +++++++++++++++++
 .../remediated/remediated-2/src/tests.rs      | 153 ++++++++++++
 .../remediated/remediated-2/src/weights.rs    |  46 ++++
 .../remediated/remediated-3/Cargo.toml        |  39 +++
 .../remediated/remediated-3/src/lib.rs        | 234 +++++++++++++++++
 .../remediated/remediated-3/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-3/src/weights.rs    |  46 ++++
 .../remediated/remediated-4/Cargo.toml        |  39 +++
 .../remediated/remediated-4/src/lib.rs        | 230 +++++++++++++++++
 .../remediated/remediated-4/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-4/src/weights.rs    |  46 ++++
 .../remediated/remediated-5/Cargo.toml        |  39 +++
 .../remediated/remediated-5/src/lib.rs        | 228 +++++++++++++++++
 .../remediated/remediated-5/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-5/src/weights.rs    |  46 ++++
 .../remediated/remediated-6/Cargo.toml        |  39 +++
 .../remediated/remediated-6/src/lib.rs        | 228 +++++++++++++++++
 .../remediated/remediated-6/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-6/src/weights.rs    |  46 ++++
 .../remediated/remediated-7/Cargo.toml        |  39 +++
 .../remediated/remediated-7/src/lib.rs        | 228 +++++++++++++++++
 .../remediated/remediated-7/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-7/src/weights.rs    |  46 ++++
 .../remediated/remediated-8/Cargo.toml        |  39 +++
 .../remediated/remediated-8/src/lib.rs        | 228 +++++++++++++++++
 .../remediated/remediated-8/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-8/src/weights.rs    |  46 ++++
 .../remediated/remediated-9/Cargo.toml        |  39 +++
 .../remediated/remediated-9/src/lib.rs        | 232 +++++++++++++++++
 .../remediated/remediated-9/src/tests.rs      | 142 +++++++++++
 .../remediated/remediated-9/src/weights.rs    |  46 ++++
 42 files changed, 4786 insertions(+), 25 deletions(-)
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/weights.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/Cargo.toml
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
 create mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/weights.rs

diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
index 7095dc67..fe10587d 100644
--- a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -44,19 +44,19 @@ use std::{
 const LINT_MESSAGE: &str = "Saturating arithmetic may silently generate incorrect results.";
 const F: bool = false;
 const T: bool = true;
-const RELEVANT_FUNCTIONS: [(&str, bool, bool); 12] = [
-    ("saturating_add",        T, T),
-    ("saturating_add_signed", T, F),
-    ("saturating_sub",        T, T),
-    ("saturating_mul",        T, T),
-    ("saturating_div",        T, F),
-    ("saturating_pow",        T, T),
-    ("saturating_less_one",   F, T),
-    ("saturating_plus_one",   F, T),
-    ("saturating_inc",        F, T),
-    ("saturating_dec",        F, T),
-    ("saturating_accrue",     F, T),
-    ("saturating_reduce",     F, T),
+const RELEVANT_FUNCTIONS: [(&str, bool, bool, Option<&str>); 12] = [
+    ("saturating_add",        T, T, Some("checked_add")),
+    ("saturating_add_signed", T, F, Some("checked_add_signed")),
+    ("saturating_sub",        T, T, Some("checked_sub")),
+    ("saturating_mul",        T, T, Some("checked_mul")),
+    ("saturating_div",        T, F, Some("checked_div")),
+    ("saturating_pow",        T, T, None),
+    ("saturating_less_one",   F, T, None),
+    ("saturating_plus_one",   F, T, None),
+    ("saturating_inc",        F, T, None),
+    ("saturating_dec",        F, T, None),
+    ("saturating_accrue",     F, T, None),
+    ("saturating_reduce",     F, T, None),
 ];
 const IGNORED_FUNCTIONS: [&str; 1] = [
     "size_hint",
@@ -85,13 +85,15 @@ dylint_linting::declare_late_lint! {
 struct FunctionAvailability{
     pub available_on_std: bool,
     pub available_on_substrate: bool,
+    pub suggested_replacement: Option<String>,
 }
 
 impl FunctionAvailability{
-    pub fn new(available_on_std: bool, available_on_substrate: bool) -> Self{
+    pub fn new(available_on_std: bool, available_on_substrate: bool, suggested_replacement: &Option<&str>) -> Self{
         Self{
             available_on_std,
             available_on_substrate,
+            suggested_replacement: suggested_replacement.and_then(|x| Some(x.to_string()))
         }
     }
 }
@@ -107,7 +109,14 @@ impl GlobalState{
         Self{
             relevant_functions: RELEVANT_FUNCTIONS
                 .iter()
-                .map(|(x, y, z)| (x.to_string(), FunctionAvailability::new(*y, *z)))
+                .map(|(x, y, z, a)| (
+                    x.to_string(),
+                    FunctionAvailability::new(
+                        *y,
+                        *z,
+                        a
+                    )
+                ))
                 .collect(),
             ignored_functions: Self::to_hash_set(&IGNORED_FUNCTIONS[..]),
             ignored_types: Self::to_hash_set(&IGNORED_TYPES[..]),
@@ -156,20 +165,31 @@ static GLOBAL_STATE: Mutex<Option<Arc<Mutex<GlobalState>>>> = Mutex::new(None);
 fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()>{
     let (method_name, receiver, _args, _span) = expr_to_method_call(&expr.kind)?;
     let method_name_str = method_name.ident.name.as_str();
-    let _availability = GlobalState::method_is_relevant(method_name_str)?;
+    let availability = GlobalState::method_is_relevant(method_name_str)?;
     let node_type = get_node_type(cx, &receiver.hir_id);
     if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)){
         None?;
     }
-    span_lint_and_sugg(
-        cx,
-        SATURATING_ARITHMETIC,
-        method_name.ident.span,
-        LINT_MESSAGE,
-        "Instead of overflowing, saturating arithmetic clamps the result to the representation limit for the data type. Consider checked arithmetic instead",
-        format!("checked_{}", &method_name_str[11..]),
-        Applicability::MaybeIncorrect,
-    );
+    if let Some(replacement) = availability.suggested_replacement{
+        span_lint_and_sugg(
+            cx,
+            SATURATING_ARITHMETIC,
+            method_name.ident.span,
+            LINT_MESSAGE,
+            "Saturating arithmetic clamps the result to the representation limit for the data type instead of overflowing. Consider checked arithmetic instead",
+            replacement,
+            Applicability::MaybeIncorrect,
+        );
+    }else{
+        span_lint_and_help(
+            cx,
+            SATURATING_ARITHMETIC,
+            method_name.ident.span,
+            LINT_MESSAGE,
+            None,
+            "Saturating arithmetic clamps the result to the representation limit for the data type instead of overflowing. Consider checked arithmetic instead.",
+        );
+    }
     None
 }
 
diff --git a/test-cases/substrate-pallets/Cargo.lock b/test-cases/substrate-pallets/Cargo.lock
index 7532dab4..daf93dbe 100644
--- a/test-cases/substrate-pallets/Cargo.lock
+++ b/test-cases/substrate-pallets/Cargo.lock
@@ -1998,6 +1998,156 @@ dependencies = [
  "sp-runtime",
 ]
 
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-1"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-10"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-2"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-3"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-4"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-5"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-6"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-7"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-8"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
+[[package]]
+name = "pallet-saturating-arithmetic-remediated-9"
+version = "27.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "pallet-saturating-arithmetic-vulnerable-1"
 version = "27.0.0"
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/Cargo.toml
new file mode 100644
index 00000000..2501adc1
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-1"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
new file mode 100644
index 00000000..31292f78
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
@@ -0,0 +1,236 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{
+        Bounded,
+        DispatchInfoOf,
+        SaturatedConversion,
+        SignedExtension,
+        CheckedAdd,
+    },
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.map_or(Some(increase_by), |d| d.checked_add(&increase_by));
+                if new_dummy.is_none(){
+                    error = Err(Error::<T>::IntegerOverflow);
+                    return;
+                }
+                *dummy = new_dummy;
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/Cargo.toml
new file mode 100644
index 00000000..b83e3b04
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-10"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
new file mode 100644
index 00000000..2a5328e5
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
@@ -0,0 +1,232 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_sub(&increase_by);
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/Cargo.toml
new file mode 100644
index 00000000..5559b555
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-2"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
new file mode 100644
index 00000000..6febb480
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
@@ -0,0 +1,234 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedMul, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn multiply_dummy(origin: OriginFor<T>, factor: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.and_then(|d| Some(d.checked_mul(&factor)));
+                if new_dummy.is_none(){
+                    return;
+                }
+                let new_dummy = new_dummy.unwrap();
+                if new_dummy.is_none(){
+                    error = Err(Error::<T>::IntegerOverflow);
+                    return;
+                }
+                *dummy = new_dummy;
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: factor,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
new file mode 100644
index 00000000..c424e185
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
@@ -0,0 +1,153 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+            bar: alloc::vec![(1, 2), (2, 3)],
+            foo: 24,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn it_works_for_default_value() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(Foo::<Test>::get(), 24);
+        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
+        assert_eq!(Foo::<Test>::get(), 25);
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/weights.rs
new file mode 100644
index 00000000..407d3884
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn multiply_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn multiply_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn multiply_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/Cargo.toml
new file mode 100644
index 00000000..a909b251
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-3"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
new file mode 100644
index 00000000..61aed2e3
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
@@ -0,0 +1,234 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, decrease_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.and_then(|d| Some(d.checked_sub(&decrease_by)));
+                if new_dummy.is_none(){
+                    return;
+                }
+                let new_dummy = new_dummy.unwrap();
+                if new_dummy.is_none(){
+                    error = Err(Error::<T>::IntegerOverflow);
+                    return;
+                }
+                *dummy = new_dummy;
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: decrease_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/Cargo.toml
new file mode 100644
index 00000000..c2643d0d
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-4"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
new file mode 100644
index 00000000..b48ae5c8
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
@@ -0,0 +1,230 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, SignedExtension, checked_pow},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn cube_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                let new_dummy = dummy.and_then(|d| Some(checked_pow(d, 3_usize)));
+                if new_dummy.is_none(){
+                    return;
+                }
+                let new_dummy = new_dummy.unwrap();
+                if new_dummy.is_none(){
+                    error = Err(Error::<T>::IntegerOverflow);
+                    return;
+                }
+                *dummy = new_dummy;
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/weights.rs
new file mode 100644
index 00000000..86bd1941
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn cube_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn cube_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn cube_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/Cargo.toml
new file mode 100644
index 00000000..d7129c77
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-5"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
new file mode 100644
index 00000000..07486341
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
@@ -0,0 +1,228 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_sub(&T::Balance::from(1_u32));
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/Cargo.toml
new file mode 100644
index 00000000..ef7aa78d
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-6"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
new file mode 100644
index 00000000..07486341
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
@@ -0,0 +1,228 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_sub(&T::Balance::from(1_u32));
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/Cargo.toml
new file mode 100644
index 00000000..b0144fdd
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-7"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
new file mode 100644
index 00000000..70e0b21f
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
@@ -0,0 +1,228 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_add(&T::Balance::from(1_u32));
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/Cargo.toml
new file mode 100644
index 00000000..20cb6068
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-8"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
new file mode 100644
index 00000000..70e0b21f
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
@@ -0,0 +1,228 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn decrement_dummy(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_add(&T::Balance::from(1_u32));
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy);
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy,
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/weights.rs
new file mode 100644
index 00000000..844a22e9
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn decrement_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn decrement_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/Cargo.toml b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/Cargo.toml
new file mode 100644
index 00000000..7fcf3f9b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-saturating-arithmetic-remediated-9"
+version = "27.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+description = "FRAME example pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-balances = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
new file mode 100644
index 00000000..ddf097fc
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
@@ -0,0 +1,232 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate alloc;
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_support::{
+    dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+    traits::IsSubType,
+    weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    transaction_validity::{
+        InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+    },
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+        let multiplier = self.0;
+        // *target.0 is the amount passed into the extrinsic
+        let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+        Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+    }
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+        if *target.0 > <BalanceOf<T>>::from(1000u32) {
+            DispatchClass::Operational
+        } else {
+            DispatchClass::Normal
+        }
+    }
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+    fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+        Pays::Yes
+    }
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+    #[pallet::config]
+    pub trait Config: pallet_balances::Config + frame_system::Config {
+        #[pallet::constant]
+        type MagicNumber: Get<Self::Balance>;
+
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            Weight::zero()
+        }
+
+        fn on_finalize(_n: BlockNumberFor<T>) {}
+
+        fn offchain_worker(_n: BlockNumberFor<T>) {}
+    }
+
+    #[pallet::error]
+    pub enum Error<T> {
+        IntegerOverflow,
+    }
+  
+    #[pallet::call(weight(<T as Config>::WeightInfo))]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0)]
+        pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+
+            let mut error = Ok(());
+            <Dummy<T>>::mutate(|dummy| {
+                if let Some(x) = dummy{
+                    let new_dummy = x.checked_add(&increase_by);
+                    if new_dummy.is_none(){
+                        error = Err(Error::<T>::IntegerOverflow);
+                        return;
+                    }
+                    *dummy = new_dummy;
+                }
+            });
+
+            error?;
+
+            Self::deposit_event(Event::AccumulateDummy {
+                balance: increase_by,
+            });
+
+            Ok(())
+        }
+
+        #[pallet::call_index(1)]
+        #[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+        pub fn set_dummy(
+            origin: OriginFor<T>,
+            #[pallet::compact] new_value: T::Balance,
+        ) -> DispatchResult {
+            ensure_root(origin)?;
+
+            info!("New value is now: {:?}", new_value);
+
+            <Dummy<T>>::put(new_value);
+
+            Self::deposit_event(Event::SetDummy { balance: new_value });
+
+            Ok(())
+        }
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        AccumulateDummy {
+            balance: BalanceOf<T>,
+        },
+        SetDummy {
+            balance: BalanceOf<T>,
+        },
+        SetBar {
+            account: T::AccountId,
+            balance: BalanceOf<T>,
+        },
+    }
+
+    #[pallet::storage]
+    pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+    #[pallet::storage]
+    pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+    #[pallet::genesis_config]
+    #[derive(frame_support::DefaultNoBound)]
+    pub struct GenesisConfig<T: Config> {
+        pub dummy: T::Balance,
+    }
+
+    #[pallet::genesis_build]
+    impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+        fn build(&self) {
+            <Dummy<T>>::put(self.dummy);
+        }
+    }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> core::fmt::Debug for WatchDummy<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "WatchDummy")
+    }
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+    <T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+    const IDENTIFIER: &'static str = "WatchDummy";
+    type AccountId = T::AccountId;
+    type Call = <T as frame_system::Config>::RuntimeCall;
+    type AdditionalSigned = ();
+    type Pre = ();
+
+    fn additional_signed(&self) -> core::result::Result<(), TransactionValidityError> {
+        Ok(())
+    }
+
+    fn pre_dispatch(
+        self,
+        who: &Self::AccountId,
+        call: &Self::Call,
+        info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> Result<Self::Pre, TransactionValidityError> {
+        self.validate(who, call, info, len).map(|_| ())
+    }
+
+    fn validate(
+        &self,
+        _who: &Self::AccountId,
+        call: &Self::Call,
+        _info: &DispatchInfoOf<Self::Call>,
+        len: usize,
+    ) -> TransactionValidity {
+        if len > 200 {
+            return InvalidTransaction::ExhaustsResources.into();
+        }
+
+        match call.is_sub_type() {
+            Some(Call::set_dummy { .. }) => {
+                sp_runtime::print("set_dummy was received.");
+
+                let valid_tx = ValidTransaction {
+                    priority: Bounded::max_value(),
+                    ..Default::default()
+                };
+                Ok(valid_tx)
+            }
+            _ => Ok(Default::default()),
+        }
+    }
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
new file mode 100644
index 00000000..3daa0b90
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
@@ -0,0 +1,142 @@
+use crate as pallet_example_basic;
+use crate::*;
+use frame_support::{
+    assert_ok, derive_impl,
+    dispatch::{DispatchInfo, GetDispatchInfo},
+    traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+    traits::{BlakeTwo256, IdentityLookup},
+    BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+    pub enum Test
+    {
+        System: frame_system,
+        Balances: pallet_balances,
+        Example: pallet_example_basic,
+    }
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+    type BaseCallFilter = frame_support::traits::Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type DbWeight = ();
+    type RuntimeOrigin = RuntimeOrigin;
+    type Nonce = u64;
+    type Hash = H256;
+    type RuntimeCall = RuntimeCall;
+    type Hashing = BlakeTwo256;
+    type AccountId = u64;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Block = Block;
+    type RuntimeEvent = RuntimeEvent;
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = pallet_balances::AccountData<u64>;
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Test {
+    type AccountStore = System;
+}
+
+impl Config for Test {
+    type MagicNumber = ConstU64<1_000_000_000>;
+    type RuntimeEvent = RuntimeEvent;
+    type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = RuntimeGenesisConfig {
+        system: Default::default(),
+        balances: Default::default(),
+        example: pallet_example_basic::GenesisConfig {
+            dummy: 42,
+        },
+    }
+    .build_storage()
+    .unwrap();
+    t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+    new_test_ext().execute_with(|| {
+        let val1 = 42;
+        let val2 = 27;
+        assert_eq!(Dummy::<Test>::get(), Some(val1));
+
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
+
+        <Example as OnInitialize<u64>>::on_initialize(2);
+        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
+    });
+}
+
+#[test]
+fn set_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let test_val = 133;
+        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
+        assert_eq!(Dummy::<Test>::get(), Some(test_val));
+    });
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+    new_test_ext().execute_with(|| {
+        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+        let info = DispatchInfo::default();
+
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData)
+                .validate(&1, &call, &info, 150)
+                .unwrap()
+                .priority,
+            u64::MAX,
+        );
+        assert_eq!(
+            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+            InvalidTransaction::ExhaustsResources.into(),
+        );
+    })
+}
+
+#[test]
+fn counted_map_works() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(CountedMap::<Test>::count(), 0);
+        CountedMap::<Test>::insert(3, 3);
+        assert_eq!(CountedMap::<Test>::count(), 1);
+    })
+}
+
+#[test]
+fn weights_work() {
+    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+    let info1 = default_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > 0);
+    assert_eq!(
+        info1.weight,
+        <Test as Config>::WeightInfo::accumulate_dummy()
+    );
+
+    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+    let info2 = custom_call.get_dispatch_info();
+    assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/weights.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/weights.rs
new file mode 100644
index 00000000..43d6814b
--- /dev/null
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/weights.rs
@@ -0,0 +1,46 @@
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}
+
+impl WeightInfo for () {
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000_u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0_u64, 0)
+			.saturating_add(Weight::from_parts(520_u64, 0).saturating_mul(x as u64))
+	}
+}

From c140e654867a5136ee2e96fdf8bd74ad409214f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 15:27:09 -0300
Subject: [PATCH 25/30] Removed tests.

---
 .../remediated/remediated-1/src/lib.rs        |   3 -
 .../remediated/remediated-1/src/tests.rs      | 142 ----------------
 .../remediated/remediated-10/src/lib.rs       |   3 -
 .../remediated/remediated-10/src/tests.rs     | 142 ----------------
 .../remediated/remediated-2/src/lib.rs        |   3 -
 .../remediated/remediated-2/src/tests.rs      | 153 ------------------
 .../remediated/remediated-3/src/lib.rs        |   3 -
 .../remediated/remediated-3/src/tests.rs      | 142 ----------------
 .../remediated/remediated-4/src/lib.rs        |   3 -
 .../remediated/remediated-4/src/tests.rs      | 142 ----------------
 .../remediated/remediated-5/src/lib.rs        |   3 -
 .../remediated/remediated-5/src/tests.rs      | 142 ----------------
 .../remediated/remediated-6/src/lib.rs        |   3 -
 .../remediated/remediated-6/src/tests.rs      | 142 ----------------
 .../remediated/remediated-7/src/lib.rs        |   3 -
 .../remediated/remediated-7/src/tests.rs      | 142 ----------------
 .../remediated/remediated-8/src/lib.rs        |   3 -
 .../remediated/remediated-8/src/tests.rs      | 142 ----------------
 .../remediated/remediated-9/src/lib.rs        |   3 -
 .../remediated/remediated-9/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-1/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-1/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-10/src/lib.rs       |   3 -
 .../vulnerable/vulnerable-10/src/tests.rs     | 142 ----------------
 .../vulnerable/vulnerable-2/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-2/src/tests.rs      | 153 ------------------
 .../vulnerable/vulnerable-3/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-3/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-4/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-4/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-5/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-5/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-6/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-6/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-7/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-7/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-8/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-8/src/tests.rs      | 142 ----------------
 .../vulnerable/vulnerable-9/src/lib.rs        |   3 -
 .../vulnerable/vulnerable-9/src/tests.rs      | 142 ----------------
 40 files changed, 2922 deletions(-)
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
 delete mode 100644 test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs

diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
index 31292f78..97349875 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
@@ -27,9 +27,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
index 2a5328e5..79dd3949 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
index 6febb480..edc07627 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
deleted file mode 100644
index c424e185..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/tests.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-            bar: alloc::vec![(1, 2), (2, 3)],
-            foo: 24,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn it_works_for_default_value() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(Foo::<Test>::get(), 24);
-        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
-        assert_eq!(Foo::<Test>::get(), 25);
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
index 61aed2e3..38712fc6 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
index b48ae5c8..e2c7d2d7 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
index 07486341..cdcf6add 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
index 07486341..cdcf6add 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
index 70e0b21f..2382e883 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
index 70e0b21f..2382e883 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
index ddf097fc..9cdde448 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
index b44bfb1b..daf17a41 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-1/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
index 3a4ff9c8..c5d751c2 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
index 394722cf..72662eb8 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
deleted file mode 100644
index c424e185..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/tests.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-            bar: alloc::vec![(1, 2), (2, 3)],
-            foo: 24,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn it_works_for_default_value() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(Foo::<Test>::get(), 24);
-        assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
-        assert_eq!(Foo::<Test>::get(), 25);
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
index 13ce0b47..188a3265 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-3/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
index d222c030..5947e4ff 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-4/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
index 56888396..66237096 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
index a188222f..1fa3db34 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
index b553c160..cf77f314 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
index 54bb6a9a..0e9c71ce 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
index 9fa74293..2cd9df1e 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
@@ -21,9 +21,6 @@ use sp_runtime::{
 
 pub use pallet::*;
 
-#[cfg(test)]
-mod tests;
-
 pub mod weights;
 pub use weights::*;
 
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs
deleted file mode 100644
index 3daa0b90..00000000
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/tests.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use crate as pallet_example_basic;
-use crate::*;
-use frame_support::{
-    assert_ok, derive_impl,
-    dispatch::{DispatchInfo, GetDispatchInfo},
-    traits::{ConstU64, OnInitialize},
-};
-use sp_core::H256;
-use sp_runtime::{
-    traits::{BlakeTwo256, IdentityLookup},
-    BuildStorage,
-};
-
-type Block = frame_system::mocking::MockBlock<Test>;
-
-frame_support::construct_runtime!(
-    pub enum Test
-    {
-        System: frame_system,
-        Balances: pallet_balances,
-        Example: pallet_example_basic,
-    }
-);
-
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
-impl frame_system::Config for Test {
-    type BaseCallFilter = frame_support::traits::Everything;
-    type BlockWeights = ();
-    type BlockLength = ();
-    type DbWeight = ();
-    type RuntimeOrigin = RuntimeOrigin;
-    type Nonce = u64;
-    type Hash = H256;
-    type RuntimeCall = RuntimeCall;
-    type Hashing = BlakeTwo256;
-    type AccountId = u64;
-    type Lookup = IdentityLookup<Self::AccountId>;
-    type Block = Block;
-    type RuntimeEvent = RuntimeEvent;
-    type Version = ();
-    type PalletInfo = PalletInfo;
-    type AccountData = pallet_balances::AccountData<u64>;
-    type OnNewAccount = ();
-    type OnKilledAccount = ();
-    type SystemWeightInfo = ();
-    type SS58Prefix = ();
-    type OnSetCode = ();
-    type MaxConsumers = frame_support::traits::ConstU32<16>;
-}
-
-#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
-impl pallet_balances::Config for Test {
-    type AccountStore = System;
-}
-
-impl Config for Test {
-    type MagicNumber = ConstU64<1_000_000_000>;
-    type RuntimeEvent = RuntimeEvent;
-    type WeightInfo = ();
-}
-
-pub fn new_test_ext() -> sp_io::TestExternalities {
-    let t = RuntimeGenesisConfig {
-        system: Default::default(),
-        balances: Default::default(),
-        example: pallet_example_basic::GenesisConfig {
-            dummy: 42,
-        },
-    }
-    .build_storage()
-    .unwrap();
-    t.into()
-}
-
-#[test]
-fn it_works_for_optional_value() {
-    new_test_ext().execute_with(|| {
-        let val1 = 42;
-        let val2 = 27;
-        assert_eq!(Dummy::<Test>::get(), Some(val1));
-
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2));
-
-        <Example as OnInitialize<u64>>::on_initialize(2);
-        assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
-        assert_eq!(Dummy::<Test>::get(), Some(val1 + val2 + val1));
-    });
-}
-
-#[test]
-fn set_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let test_val = 133;
-        assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val));
-        assert_eq!(Dummy::<Test>::get(), Some(test_val));
-    });
-}
-
-#[test]
-fn signed_ext_watch_dummy_works() {
-    new_test_ext().execute_with(|| {
-        let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
-        let info = DispatchInfo::default();
-
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData)
-                .validate(&1, &call, &info, 150)
-                .unwrap()
-                .priority,
-            u64::MAX,
-        );
-        assert_eq!(
-            WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
-            InvalidTransaction::ExhaustsResources.into(),
-        );
-    })
-}
-
-#[test]
-fn counted_map_works() {
-    new_test_ext().execute_with(|| {
-        assert_eq!(CountedMap::<Test>::count(), 0);
-        CountedMap::<Test>::insert(3, 3);
-        assert_eq!(CountedMap::<Test>::count(), 1);
-    })
-}
-
-#[test]
-fn weights_work() {
-    let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
-    let info1 = default_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > 0);
-    assert_eq!(
-        info1.weight,
-        <Test as Config>::WeightInfo::accumulate_dummy()
-    );
-
-    let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
-    let info2 = custom_call.get_dispatch_info();
-    assert!(info1.weight.ref_time() > info2.weight.ref_time());
-}

From b9f2cf48e69115515585d84cb2256e62e4981b1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 15:52:59 -0300
Subject: [PATCH 26/30] Skip GetShortMessage().

---
 scripts/cs/run-tests/TestUtils.cs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/scripts/cs/run-tests/TestUtils.cs b/scripts/cs/run-tests/TestUtils.cs
index 95c29472..bf6d6dca 100644
--- a/scripts/cs/run-tests/TestUtils.cs
+++ b/scripts/cs/run-tests/TestUtils.cs
@@ -189,7 +189,15 @@ private static bool RunUnitTests(string root, string blockchain)
 
             Debug.Assert(stdout != null);
 
-            var detectorsMetadata = JsonConvert.DeserializeObject<ScoutMetadata>(stdout);
+            ScoutMetadata? detectorsMetadata = null;
+            try
+            {
+                detectorsMetadata = JsonConvert.DeserializeObject<ScoutMetadata>(stdout);
+            }
+            catch
+            {
+            }
+
             if (detectorsMetadata == null)
             {
                 AutoConsoleColor.WriteLine(ConsoleColor.Red, $"Failed to extract JSON from metadata.");
@@ -215,8 +223,8 @@ private static bool RunScoutTests(string blockchain, string detector, string roo
             var localDetectors = Path.Join(new[]
                 { Environment.CurrentDirectory, "detectors" });
 
-            if (GetShortMessage(detector, localDetectors, root) == null)
-                return false;
+            //if (GetShortMessage(detector, localDetectors, root) == null)
+            //    return false;
 
             var temp = Path.GetTempFileName();
 

From 04a1a0c1821190ee310f46705fcd44f602b496bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 15:59:59 -0300
Subject: [PATCH 27/30] cargo clippy

---
 .../substrate-pallets/saturating-arithmetic/src/lib.rs     | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
index fe10587d..a6da2d09 100644
--- a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -81,6 +81,7 @@ dylint_linting::declare_late_lint! {
     LINT_MESSAGE
 }
 
+#[allow(dead_code)]
 #[derive(Clone)]
 struct FunctionAvailability{
     pub available_on_std: bool,
@@ -153,10 +154,10 @@ impl GlobalState{
             false
         }
     }
-    pub fn function_is_ignored(name: &String) -> bool{
+    pub fn function_is_ignored(name: &str) -> bool{
         let gs = Self::get_state();
         let lock = gs.lock().unwrap();
-        lock.ignored_functions.contains(name.as_str())
+        lock.ignored_functions.contains(name)
     }
 }
 
@@ -193,7 +194,7 @@ fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
     None
 }
 
-fn ident<'a>(f: &FnKind<'a>) -> String{
+fn ident(f: &FnKind<'_>) -> String{
     match f{
         FnKind::ItemFn(id, _, _) => id.name.to_ident_string(),
         FnKind::Method(id, _) => id.name.to_ident_string(),

From 3db78372f58b70fe59f59dc404469d719feaecd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 16:00:58 -0300
Subject: [PATCH 28/30] cargo fmt

---
 .../saturating-arithmetic/src/lib.rs          | 137 ++++++++----------
 .../remediated/remediated-1/src/lib.rs        |  12 +-
 .../remediated/remediated-10/src/lib.rs       |   8 +-
 .../remediated/remediated-2/src/lib.rs        |  12 +-
 .../remediated/remediated-3/src/lib.rs        |   8 +-
 .../remediated/remediated-4/src/lib.rs        |   8 +-
 .../remediated/remediated-5/src/lib.rs        |   8 +-
 .../remediated/remediated-6/src/lib.rs        |   8 +-
 .../remediated/remediated-7/src/lib.rs        |   8 +-
 .../remediated/remediated-8/src/lib.rs        |   8 +-
 .../remediated/remediated-9/src/lib.rs        |   8 +-
 .../vulnerable/vulnerable-10/src/lib.rs       |   2 +-
 .../vulnerable/vulnerable-2/src/lib.rs        |   4 +-
 .../vulnerable/vulnerable-5/src/lib.rs        |   2 +-
 .../vulnerable/vulnerable-6/src/lib.rs        |   2 +-
 .../vulnerable/vulnerable-7/src/lib.rs        |   2 +-
 .../vulnerable/vulnerable-8/src/lib.rs        |   2 +-
 .../vulnerable/vulnerable-9/src/lib.rs        |   2 +-
 18 files changed, 104 insertions(+), 137 deletions(-)

diff --git a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
index a6da2d09..e5030a22 100644
--- a/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
+++ b/detectors/substrate-pallets/saturating-arithmetic/src/lib.rs
@@ -1,69 +1,50 @@
 #![feature(rustc_private)]
 
 extern crate rustc_ast;
+extern crate rustc_errors;
 extern crate rustc_hir;
-extern crate rustc_span;
 extern crate rustc_middle;
-extern crate rustc_errors;
+extern crate rustc_span;
 
-use clippy_utils::diagnostics::{
-    span_lint_and_sugg,
-    span_lint_and_help,
-};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use common::analysis::{decomposers::*, get_node_type};
 use common::{
     declarations::{Severity, VulnerabilityClass},
     macros::expose_lint_info,
 };
+use rustc_errors::Applicability;
 use rustc_hir::{
     def_id::LocalDefId,
     intravisit::{walk_expr, FnKind, Visitor},
     Body, Expr, FnDecl,
 };
-use rustc_errors::Applicability;
-use rustc_lint::{
-    LateContext,
-    LateLintPass,
-};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::Span;
-use common::analysis::{
-    get_node_type,
-    decomposers::*,
-};
 use std::{
-    collections::{
-        HashSet,
-        HashMap,
-    },
+    collections::{HashMap, HashSet},
     ops::Deref,
-    sync::{
-        Arc,
-        Mutex,
-    },
+    sync::{Arc, Mutex},
 };
 
 const LINT_MESSAGE: &str = "Saturating arithmetic may silently generate incorrect results.";
 const F: bool = false;
 const T: bool = true;
 const RELEVANT_FUNCTIONS: [(&str, bool, bool, Option<&str>); 12] = [
-    ("saturating_add",        T, T, Some("checked_add")),
+    ("saturating_add", T, T, Some("checked_add")),
     ("saturating_add_signed", T, F, Some("checked_add_signed")),
-    ("saturating_sub",        T, T, Some("checked_sub")),
-    ("saturating_mul",        T, T, Some("checked_mul")),
-    ("saturating_div",        T, F, Some("checked_div")),
-    ("saturating_pow",        T, T, None),
-    ("saturating_less_one",   F, T, None),
-    ("saturating_plus_one",   F, T, None),
-    ("saturating_inc",        F, T, None),
-    ("saturating_dec",        F, T, None),
-    ("saturating_accrue",     F, T, None),
-    ("saturating_reduce",     F, T, None),
-];
-const IGNORED_FUNCTIONS: [&str; 1] = [
-    "size_hint",
-];
-const IGNORED_TYPES: [&str; 1] = [
-    "sp_weights::weight_v2::Weight",
+    ("saturating_sub", T, T, Some("checked_sub")),
+    ("saturating_mul", T, T, Some("checked_mul")),
+    ("saturating_div", T, F, Some("checked_div")),
+    ("saturating_pow", T, T, None),
+    ("saturating_less_one", F, T, None),
+    ("saturating_plus_one", F, T, None),
+    ("saturating_inc", F, T, None),
+    ("saturating_dec", F, T, None),
+    ("saturating_accrue", F, T, None),
+    ("saturating_reduce", F, T, None),
 ];
+const IGNORED_FUNCTIONS: [&str; 1] = ["size_hint"];
+const IGNORED_TYPES: [&str; 1] = ["sp_weights::weight_v2::Weight"];
 
 #[expose_lint_info]
 pub static SATURATING_ARITHMETIC_INFO: LintInfo = LintInfo {
@@ -83,78 +64,76 @@ dylint_linting::declare_late_lint! {
 
 #[allow(dead_code)]
 #[derive(Clone)]
-struct FunctionAvailability{
+struct FunctionAvailability {
     pub available_on_std: bool,
     pub available_on_substrate: bool,
     pub suggested_replacement: Option<String>,
 }
 
-impl FunctionAvailability{
-    pub fn new(available_on_std: bool, available_on_substrate: bool, suggested_replacement: &Option<&str>) -> Self{
-        Self{
+impl FunctionAvailability {
+    pub fn new(
+        available_on_std: bool,
+        available_on_substrate: bool,
+        suggested_replacement: &Option<&str>,
+    ) -> Self {
+        Self {
             available_on_std,
             available_on_substrate,
-            suggested_replacement: suggested_replacement.and_then(|x| Some(x.to_string()))
+            suggested_replacement: suggested_replacement.and_then(|x| Some(x.to_string())),
         }
     }
 }
 
-struct GlobalState{
+struct GlobalState {
     relevant_functions: HashMap<String, FunctionAvailability>,
     ignored_functions: HashSet<String>,
     ignored_types: HashSet<String>,
 }
 
-impl GlobalState{
-    pub fn new() -> Self{
-        Self{
+impl GlobalState {
+    pub fn new() -> Self {
+        Self {
             relevant_functions: RELEVANT_FUNCTIONS
                 .iter()
-                .map(|(x, y, z, a)| (
-                    x.to_string(),
-                    FunctionAvailability::new(
-                        *y,
-                        *z,
-                        a
-                    )
-                ))
+                .map(|(x, y, z, a)| (x.to_string(), FunctionAvailability::new(*y, *z, a)))
                 .collect(),
             ignored_functions: Self::to_hash_set(&IGNORED_FUNCTIONS[..]),
             ignored_types: Self::to_hash_set(&IGNORED_TYPES[..]),
         }
     }
-    fn to_hash_set(strings: &[&str]) -> HashSet<String>{
+    fn to_hash_set(strings: &[&str]) -> HashSet<String> {
         strings
             .iter()
             .map(|x| x.to_string())
             .collect::<HashSet<_>>()
     }
-    fn get_state() -> Arc<Mutex<GlobalState>>{
+    fn get_state() -> Arc<Mutex<GlobalState>> {
         let mut gs = GLOBAL_STATE.lock().unwrap();
-        match gs.deref(){
+        match gs.deref() {
             None => {
-                let ret = Arc::<Mutex<GlobalState>>::new(Mutex::<GlobalState>::new(GlobalState::new()));
+                let ret =
+                    Arc::<Mutex<GlobalState>>::new(Mutex::<GlobalState>::new(GlobalState::new()));
                 *gs = Some(ret.clone());
                 ret
-            },
+            }
             Some(p) => p.clone(),
         }
     }
-    pub fn method_is_relevant(method_name: &str) -> Option<FunctionAvailability>{
+    pub fn method_is_relevant(method_name: &str) -> Option<FunctionAvailability> {
         let gs = Self::get_state();
         let lock = gs.lock().unwrap();
         Some(lock.relevant_functions.get(method_name)?.clone())
     }
-    pub fn type_is_ignored(name: &Option<String>) -> bool{
-        if let Some(name) = name{
+    pub fn type_is_ignored(name: &Option<String>) -> bool {
+        if let Some(name) = name {
             let gs = Self::get_state();
             let lock = gs.lock().unwrap();
             lock.ignored_types.contains(name.as_str())
-        }else{
+        } else {
             false
         }
     }
-    pub fn function_is_ignored(name: &str) -> bool{
+    pub fn function_is_ignored(name: &str) -> bool {
         let gs = Self::get_state();
         let lock = gs.lock().unwrap();
         lock.ignored_functions.contains(name)
@@ -163,15 +142,15 @@ impl GlobalState{
 
 static GLOBAL_STATE: Mutex<Option<Arc<Mutex<GlobalState>>>> = Mutex::new(None);
 
-fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()>{
+fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<()> {
     let (method_name, receiver, _args, _span) = expr_to_method_call(&expr.kind)?;
     let method_name_str = method_name.ident.name.as_str();
     let availability = GlobalState::method_is_relevant(method_name_str)?;
     let node_type = get_node_type(cx, &receiver.hir_id);
-    if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)){
+    if GlobalState::type_is_ignored(&common::analysis::ty_to_string(cx, &node_type)) {
         None?;
     }
-    if let Some(replacement) = availability.suggested_replacement{
+    if let Some(replacement) = availability.suggested_replacement {
         span_lint_and_sugg(
             cx,
             SATURATING_ARITHMETIC,
@@ -181,7 +160,7 @@ fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
             replacement,
             Applicability::MaybeIncorrect,
         );
-    }else{
+    } else {
         span_lint_and_help(
             cx,
             SATURATING_ARITHMETIC,
@@ -194,15 +173,15 @@ fn detect_saturating_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
     None
 }
 
-fn ident(f: &FnKind<'_>) -> String{
-    match f{
+fn ident(f: &FnKind<'_>) -> String {
+    match f {
         FnKind::ItemFn(id, _, _) => id.name.to_ident_string(),
         FnKind::Method(id, _) => id.name.to_ident_string(),
-        FnKind::Closure => "<closure>".to_string()
+        FnKind::Closure => "<closure>".to_string(),
     }
 }
 
-struct SaturatingFinder<'a, 'b>{
+struct SaturatingFinder<'a, 'b> {
     cx: &'b LateContext<'a>,
 }
 
@@ -222,13 +201,11 @@ impl<'tcx> LateLintPass<'tcx> for SaturatingArithmetic {
         body: &'tcx Body<'tcx>,
         _: Span,
         _: LocalDefId,
-    ){
-        if GlobalState::function_is_ignored(&ident(&kind)){
+    ) {
+        if GlobalState::function_is_ignored(&ident(&kind)) {
             return;
         }
 
-        SaturatingFinder{
-            cx,
-        }.visit_expr(body.value);
+        SaturatingFinder { cx }.visit_expr(body.value);
     }
 }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
index 97349875..1a9450ed 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-1/src/lib.rs
@@ -13,13 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{
-        Bounded,
-        DispatchInfoOf,
-        SaturatedConversion,
-        SignedExtension,
-        CheckedAdd,
-    },
+    traits::{Bounded, CheckedAdd, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -93,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -103,7 +97,7 @@ pub mod pallet {
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
                 let new_dummy = dummy.map_or(Some(increase_by), |d| d.checked_add(&increase_by));
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     error = Err(Error::<T>::IntegerOverflow);
                     return;
                 }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
index 79dd3949..1f203889 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-10/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    traits::{Bounded, CheckedSub, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_sub(&increase_by);
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
index edc07627..6cea6dd7 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-2/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedMul, SignedExtension},
+    traits::{Bounded, CheckedMul, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -97,11 +97,11 @@ pub mod pallet {
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
                 let new_dummy = dummy.and_then(|d| Some(d.checked_mul(&factor)));
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     return;
                 }
                 let new_dummy = new_dummy.unwrap();
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     error = Err(Error::<T>::IntegerOverflow);
                     return;
                 }
@@ -110,9 +110,7 @@ pub mod pallet {
 
             error?;
 
-            Self::deposit_event(Event::AccumulateDummy {
-                balance: factor,
-            });
+            Self::deposit_event(Event::AccumulateDummy { balance: factor });
 
             Ok(())
         }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
index 38712fc6..aad2f126 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-3/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    traits::{Bounded, CheckedSub, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -97,11 +97,11 @@ pub mod pallet {
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
                 let new_dummy = dummy.and_then(|d| Some(d.checked_sub(&decrease_by)));
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     return;
                 }
                 let new_dummy = new_dummy.unwrap();
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     error = Err(Error::<T>::IntegerOverflow);
                     return;
                 }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
index e2c7d2d7..8d427445 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-4/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, SignedExtension, checked_pow},
+    traits::{checked_pow, Bounded, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -97,11 +97,11 @@ pub mod pallet {
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
                 let new_dummy = dummy.and_then(|d| Some(checked_pow(d, 3_usize)));
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     return;
                 }
                 let new_dummy = new_dummy.unwrap();
-                if new_dummy.is_none(){
+                if new_dummy.is_none() {
                     error = Err(Error::<T>::IntegerOverflow);
                     return;
                 }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
index cdcf6add..b7a2e6e2 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-5/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    traits::{Bounded, CheckedSub, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_sub(&T::Balance::from(1_u32));
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
index cdcf6add..b7a2e6e2 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-6/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedSub, SignedExtension},
+    traits::{Bounded, CheckedSub, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_sub(&T::Balance::from(1_u32));
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
index 2382e883..ec1fce61 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-7/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    traits::{Bounded, CheckedAdd, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_add(&T::Balance::from(1_u32));
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
index 2382e883..ec1fce61 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-8/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    traits::{Bounded, CheckedAdd, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_add(&T::Balance::from(1_u32));
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
index 9cdde448..f6186203 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/remediated/remediated-9/src/lib.rs
@@ -13,7 +13,7 @@ use frame_system::ensure_signed;
 use log::info;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{Bounded, DispatchInfoOf, SaturatedConversion, CheckedAdd, SignedExtension},
+    traits::{Bounded, CheckedAdd, DispatchInfoOf, SaturatedConversion, SignedExtension},
     transaction_validity::{
         InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
     },
@@ -87,7 +87,7 @@ pub mod pallet {
     pub enum Error<T> {
         IntegerOverflow,
     }
-  
+
     #[pallet::call(weight(<T as Config>::WeightInfo))]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -96,9 +96,9 @@ pub mod pallet {
 
             let mut error = Ok(());
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     let new_dummy = x.checked_add(&increase_by);
-                    if new_dummy.is_none(){
+                    if new_dummy.is_none() {
                         error = Err(Error::<T>::IntegerOverflow);
                         return;
                     }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
index c5d751c2..3d8b0280 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-10/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     x.saturating_reduce(increase_by);
                 }
             });
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
index 72662eb8..ea420a07 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-2/src/lib.rs
@@ -93,9 +93,7 @@ pub mod pallet {
                 *dummy = dummy.and_then(|d| Some(d.saturating_mul(factor)));
             });
 
-            Self::deposit_event(Event::AccumulateDummy {
-                balance: factor,
-            });
+            Self::deposit_event(Event::AccumulateDummy { balance: factor });
 
             Ok(())
         }
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
index 66237096..efa637d8 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-5/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     *dummy = Some(x.saturating_less_one());
                 }
             });
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
index 1fa3db34..85a2b5b1 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-6/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     x.saturating_dec();
                 }
             });
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
index cf77f314..972b4d45 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-7/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     *dummy = Some(x.saturating_plus_one());
                 }
             });
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
index 0e9c71ce..031c6f1c 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-8/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     x.saturating_inc();
                 }
             });
diff --git a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
index 2cd9df1e..c4aa6f2c 100644
--- a/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
+++ b/test-cases/substrate-pallets/saturating-arithmetic/vulnerable/vulnerable-9/src/lib.rs
@@ -90,7 +90,7 @@ pub mod pallet {
             let _sender = ensure_signed(origin)?;
 
             <Dummy<T>>::mutate(|dummy| {
-                if let Some(x) = dummy{
+                if let Some(x) = dummy {
                     x.saturating_accrue(increase_by);
                 }
             });

From 51247ca880ad8631e21fbc8de019ed153f78c9b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADctor=20M=2E=20Gonz=C3=A1lez?=
 <victor.gonzalez@nektra.com>
Date: Fri, 6 Dec 2024 16:29:08 -0300
Subject: [PATCH 29/30] Version bump.

---
 apps/cargo-scout-audit/Cargo.lock | 2 +-
 apps/cargo-scout-audit/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/cargo-scout-audit/Cargo.lock b/apps/cargo-scout-audit/Cargo.lock
index 459defe8..91f35a0e 100644
--- a/apps/cargo-scout-audit/Cargo.lock
+++ b/apps/cargo-scout-audit/Cargo.lock
@@ -402,7 +402,7 @@ dependencies = [
 
 [[package]]
 name = "cargo-scout-audit"
-version = "0.2.21"
+version = "0.3.1"
 dependencies = [
  "ansi_term",
  "anyhow",
diff --git a/apps/cargo-scout-audit/Cargo.toml b/apps/cargo-scout-audit/Cargo.toml
index 68c41bb4..432b4f40 100644
--- a/apps/cargo-scout-audit/Cargo.toml
+++ b/apps/cargo-scout-audit/Cargo.toml
@@ -20,7 +20,7 @@ license = "MIT"
 name = "cargo-scout-audit"
 readme = "../../README.md"
 repository = "https://github.com/coinfabrik/scout-audit"
-version = "0.2.21"
+version = "0.3.1"
 
 [lib]
 path = "src/lib.rs"

From 4b10e0c10ef7295bfdd470eac2f6b619a80ea977 Mon Sep 17 00:00:00 2001
From: matiascabello <matias.cabello@coinfabrik.com>
Date: Tue, 17 Dec 2024 21:14:48 -0300
Subject: [PATCH 30/30] added substrate documentation

---
 doc/substrate/README.md               | 99 +++++++++++++++++++++++++++
 doc/substrate/precision-and-recall.md | 65 ++++++++++++++++++
 2 files changed, 164 insertions(+)
 create mode 100644 doc/substrate/README.md
 create mode 100644 doc/substrate/precision-and-recall.md

diff --git a/doc/substrate/README.md b/doc/substrate/README.md
new file mode 100644
index 00000000..51288d65
--- /dev/null
+++ b/doc/substrate/README.md
@@ -0,0 +1,99 @@
+# Scout Substrate: Security Analysis Tool
+
+Scout is an extensible open-source tool intended to assist Substrate developers and auditors detect common security issues and deviations from best practices.
+
+This tool will help developers write secure and more robust Substrate pallets, runetime code and node code.
+
+Our interest in this project comes from our experience in manual auditing, our usage of comparable tools, and the development of Scout for smart contracts in [Polkadot ink!](https://github.com/CoinFabrik/scout) and [other blockchains](https://github.com/CoinFabrik/scout).
+
+## Quick Start
+
+**Install Scout Audit**
+
+Make sure that [Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html) is installed on your computer. Then, install Scout with the following command:
+
+```console
+cargo install cargo-scout-audit
+```
+
+**Run Scout Audit:**
+
+To run Scout on your project execute the following command:
+
+```console
+cargo scout-audit
+```
+
+## Detectors
+
+Currently, Scout for Substrate includes the following detectors.
+
+| Detector                      | What it detects                                                                                                        | Test cases (vulnerable/remediated)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| avoid-dispatch-error          | Usage of `DispatchError::Other` for error codes.                                                                       | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-dispatcherror-other/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-dispatcherror-other/remediated/remediated-1)                                                                                                                                                                                                                                                                                                   |
+| integer-overflow-or-underflow | Potential for integer arithmetic overflow/underflow.                                                                   | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/integer-overflow-or-underflow/vulnerable/vulnerable-1), [2](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/integer-overflow-or-underflow/vulnerable/vulnerable-2) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/integer-overflow-or-underflow/remediated/remediated-1), [2](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/integer-overflow-or-underflow/remediated/remediated-2) |
+| unsafe-expect                 | Unsafe usage of `expect`.                                                                                              | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/unsafe-expect/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/unsafe-expect/remediated)                                                                                                                                                                                                                                                                                                                                        |
+| unsafe-unwrap                 | Unsafe usage of `unwrap`.                                                                                              | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/unsafe-unwrap/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/unsafe-unwrap/remediated)                                                                                                                                                                                                                                                                                                                                        |
+| known-vulnerabilities         | Usage of dependencies with known vulnerabilities.                                                                      | [1](./test-cases/known-vulnerabilities/vulnerable/vulnerable-1/) / [1](./test-cases/known-vulnerabilities/remediated/remediated-1/)                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| avoid-panic-error             | Code panics on error instead of using descriptive enum.                                                                | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-panic-error/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-panic-error/remediated/remediated-1)                                                                                                                                                                                                                                                                                                                   |
+| iterators-over-indexing       | Iterating with hardcoded indexes is slower than using an iterator. Also, if the index is out of bounds, it will panic. | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/iterators-over-indexing/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/iterators-over-indexing/remediated/remediated-1)                                                                                                                                                                                                                                                                                                       |
+| overflow-check                | An arithmetic operation overflows or underflows the available memory allocated to the variable.                        |
+| divide-before-multiply        | Performing a division operation before a multiplication, leading to loss of precision.                                 | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/divide-before-multiply/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/divide-before-multiply/remediated/remediated-1)                                                                                                                                                                                                                                                                                                         |
+| incorrect-exponentiation      | Incorrect usage of `^`.                                                                                                | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/incorrect-exponentiation/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/incorrect-exponentiation/remediated/remediated-1)                                                                                                                                                                                                                                                                                                     |
+| avoid-unsafe-block            | Using unsafe blocks in risks code safety and reliability.                                                              | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-unsafe-block/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/avoid-unsafe-block/remediated/remediated-1)                                                                                                                                                                                                                                                                                                                 |
+| assert-violation              | Usage of the macro `assert!`, which can panic.                                                                         | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/assert-violation/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/assert-violation/remediated/remediated-1)                                                                                                                                                                                                                                                                                                                     |
+| empty-expect                  | Use of `expect` with an empty string.                                                                                  | [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/empty-expect/vulnerable/vulnerable-1) / [1](https://github.com/CoinFabrik/scout-audit/tree/main/test-cases/substrate-pallets/empty-expect/remediated/remediated-1)                                                                                                                                                                                                                                                                                                                             |
+
+## Data Set
+
+With the intention of sharing the results of our research, we have created a public repository with a collection of thoroughly analyzed audited Substrate pallets, runtime, and node code. This repository serves as a knowledge base for Substrate developers, auditors, and security researchers aiming to identify common Substrate vulnerabilities and improve the security of their projects.
+
+In addition, we've made the data set publicly available in Hugging Face.
+
+:point_right: [Data set repository](https://github.com/CoinFabrik/scout-substrate-dataset)
+
+:point_right: [Hugging Face data set](https://huggingface.co/datasets/CoinFabrik/scout-substrate-m1)
+
+:heavy_exclamation_mark: Please note that this is a work in progress. The dataset will be updated as we continue with security audit analyses, identify issues, and refine their categories.
+
+## Roadmap
+
+**Milestone 1 - Initial Vulnerability Data Set and PoC Detectors** :white_check_mark:
+
+- Data Set. An open-source GitHub repository containing annotated Substrate pallets, runtime code and node code, accompanied by a detailed document listing vulnerability classes and their locations within the code. The dataset will also be uploaded to Hugging Face data sets.
+- Proof-of-concept version of the detectors. Building on our experience with Scout for ink! and Soroban, we aim to detect 4 vulnerability classes. The tool will be delivered as source code in the repository.
+
+**Milestone 2: Extended Vulnerability Data Set and Prototype Detectors with Precision and Recall** :white_check_mark:
+
+- Prototype version of the detectors. Given our experience developing Scout for ink! and Soroban we aim to include detection of at least 5 new issue classes. Delivered as source code in the repository.
+- Extended Data Set. Extended repository of vulnerable pallets, also extending list of vulnerabilities. Updated Hugging Face data set.
+- Open Source Framework, for running analysis tools on Rust code, publicly available on CoinFabrik’s GitHub repository.
+- Detector’s evaluation report on benchmark Data Set. List of suggested vulnerability classes that appear as false negatives in the report, or have a high rate of false positives. (See an example of the evaluation report for Scout for Soroban)
+
+**Milestone 3: Prototype Tool Integration with CLI, VSCode, and CI/CD, Documentation**
+
+- A prototype tool that integrates built detectors with a CLI, a VSCode extension, and a CI/CD GitHub Action. (See existing VSCode extension and GitHub Action for ink! and Soroban)
+  Additional or improved detectors for problematic issues identified in Milestone 2. Given our experience developing and improving Scout for ink! and Soroban, we aim to improve or further develop 3 detectors.
+- Comprehensive integration tests for all detectors and features.
+- A Documentation Site (using Docusaurus or GitBook) detailing tool usage and an initial set of detectors, including nine documented detectors developed in Milestones 1 and 2. (See the documentation pages for Scout on ink! and Soroban)
+- A public project GitHub repository and website, along with an alpha tool release for selected projects and users.
+
+**Milestone 4: Final Precision and Recall Evaluation & Full Tool Release**
+
+- Final precision and recall evaluation report. Responsible disclosure of any sensible findings to their corresponding projects.
+  Improved detectors based on evaluation results. Given our experience developing Scout for ink! and Soroban, we aim to improve or develop 2 detectors after this final precision and recall.
+- Fully integrated tool with CLI, VSCode Extension, and/or CI/CD GitHub Action.
+- Public release of the tool with full documentation, publicly available on documentation sites (Docusaurus or GitBook)(See documentation examples here and here).
+- Video tutorials on how to use the tool, along with one video tutorial for each issue detected by the tool. Given our experience developing Scout for ink! and Soroban, we aim to publish between 10 and 15 video tutorials on CoinFabrik’s YouTube channel. (See Scout video tutorials for other blockchain here).
+- Release Webinar.
+- Posts on CoinFabrik’s social media.
+
+## About CoinFabrik
+
+We - [CoinFabrik](https://www.coinfabrik.com/) - are a research and development company specialized in Web3, with a strong background in cybersecurity. Founded in 2014, we have worked on over 500 blockchain-related projects, EVM based and also for Solana, Algorand, and Polkadot. Beyond development, we offer security audits through a dedicated in-house team of senior cybersecurity professionals, currently working on code in Substrate, Solidity, Clarity, Rust, and TEAL.
+
+Our team has an academic background in computer science and mathematics, with work experience focused on cybersecurity and software development, including academic publications, patents turned into products, and conference presentations. Furthermore, we have an ongoing collaboration on knowledge transfer and open-source projects with the University of Buenos Aires.
+
+## License
+
+Scout is licensed and distributed under a MIT license. [Contact us](https://www.coinfabrik.com/) if you're looking for an exception to the terms.
diff --git a/doc/substrate/precision-and-recall.md b/doc/substrate/precision-and-recall.md
new file mode 100644
index 00000000..3792d268
--- /dev/null
+++ b/doc/substrate/precision-and-recall.md
@@ -0,0 +1,65 @@
+# Scout on Substrate: Precision and Recall Report
+
+## 1. Introduction
+
+As part of the second milestone of our initiative to develop Scout static analyzer for Substrate, we aimed to assess Scout’s precision and recall across a diverse set of repositories. This analysis involved running Scout over multiple projects, including pallets and runtimes, and comparing its findings against audited and unaudited code segments to identify true positives, false positives, and compilation issues affecting the tool’s reliability.
+
+To keep track of these analyses and their details, we created a dedicated [Excel spreadsheet](https://docs.google.com/spreadsheets/d/1a7yfwU206FeSToDt74d-l6gSzhO9IYih6LK6e-07Ajo) containing the auditor’s notes, true positive/false positive classifications, and additional context on each finding. Request access if you are interested in following the analysis more closely. The selected issues from audited projects considered for this analysis were filtered from the [Scout Substrate Dataset](https://github.com/CoinFabrik/scout-substrate-dataset), ensuring that the exact location of each issue in the code was informed in the audit report.
+
+The version of Scout considered in this analysis corresponds to commit [54c2328caa0b65b30f31fc2e244ac2419a52f98f](https://github.com/CoinFabrik/scout-audit/tree/54c2328caa0b65b30f31fc2e244ac2419a52f98f).
+
+## 2. Compilation Errors
+
+During the evaluation process, Scout encountered several compilation issues when analyzing certain projects. Some minor issues were addressed by simply running `cargo update` to update dependencies. However, more complex errors were observed due to environmental incompatibilities, missing WASM targets, and misreporting statuses when the tool encountered compilation failures.
+
+### 2.1. Common Types of Compilation Errors
+
+| Type of Error                               | Description                                                                         | Example/Note                                        | Resolution Steps                                                                                                                                                                       |
+| ------------------------------------------- | ----------------------------------------------------------------------------------- | --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Dependency Conflicts / Missing Dependencies | Crates failing to compile due to out-of-date or conflicting dependencies.           | `proc-macro2` compilation error in Manta project    | Update dependencies (e.g., `cargo update`) or adjust Cargo.toml                                                                                                                        |
+| WASM-Related Issues / Missing WASM STD      | Certain projects requiring WASM targets not properly configured in the environment. | Manta Network’s `wasm-test` environment issue       | Install WASM targets, ensure proper `rustup` setup, update env.                                                                                                                        |
+| Scout Misreporting Errors as “Analyzed”     | Scout not accurately reflecting compilation failures in the summary report.         | Manta Network crate showing "Analyzed" despite fail | Addressed in [GitHub Issue #202](https://github.com/CoinFabrik/scout-audit/issues/202). Fixed status reporting in [GitHub PR #208](https://github.com/CoinFabrik/scout-audit/pull/208) |
+| Unresolved Rust Environment Configurations  | Complex runtime environment or large monorepos causing partial build failures.      | Parallel, Astar, ReefChain builds failing           | Adjust tool environment, ensure all required toolchains present                                                                                                                        |
+
+### 2.2. Steps Taken to Address Issues
+
+Initial attempts to resolve dependency-related errors involved running `cargo update` and verifying the presence of required toolchains (e.g., installing `wasm32-unknown-unknown` targets). For more complex scenarios, like those found in the Manta Network repository, a dedicated GitHub issue was opened and the issue was resolved (See [GitHub Issue #202](https://github.com/CoinFabrik/scout-audit/issues/202) and [PR #208](https://github.com/CoinFabrik/scout-audit/pull/208)). This issue focused on ensuring Scout accurately reports the "Compilation errors" status when a crate fails to compile, rather than incorrectly labeling the crate as "Analyzed."
+
+In addition to resolving reporting inaccuracies, the development team examined environmental and configuration issues. They worked on updating Scout’s handling of non-standard build environments and improving the logic that determines when a project is considered successfully analyzed versus when it is blocked by compilation hurdles.
+
+These actions have enhanced Scout’s reliability and usability, ensuring that both minor and more systemic compilation issues are clearly surfaced and properly addressed in future analyses.
+
+## 3. Precision and Recall by Detector
+
+### 3.1. On Findings from Audited Projects
+
+Of the total **N = 47** issues analyzed from audited projects extracted from the Scout Substrate Dataset, **M = 35** corresponded to code segments that could not be fully analyzed due to compilation errors. As mentioned in section `2. Compilation Errors` above, these errors were reviewed and are being followed (See [GitHub Issue #202](https://github.com/CoinFabrik/scout-audit/issues/202) and [PR #208](https://github.com/CoinFabrik/scout-audit/pull/208)) to improve Scout. This left **N - M = 12** issues associated with code segments where Scout could run without errors. All 12 issues were associated with the `integer_overflow_or_underflow` detector.
+
+For these 12 issues, our auditor first reviewed each audit finding from which the analyzed code was extracted, determining whether Scout should detect the issue at the indicated line of code or not.
+
+Our auditor’s analysis revealed that 6 of these issues were true positives—Scout accurately detected a genuine issue—while the other 6 were true negatives, as the flagged issues, despite being highlighted in audits, did not represent a detection point for the actual vulnerability and where correctly not detected by Scout.
+
+### 3.2. On Scout Findings from Unaudited Projects
+
+In addition to analyzing issues extracted from audited projects, our auditor also reviewed Scout’s detections on newer commits from the same set of projects where the tool now compiled and ran successfully, but whose code segments were not previously audited. This resulted in the analysis of an additional set of **35** detections.
+
+For each detection, the auditor assessed whether it represented a true vulnerability (true positive) or if Scout incorrectly flagged a safe code pattern (false positive). In cases where the code was deemed non-vulnerable, and Scout should not have reported it, these detections were classified as false positives. No false negatives were considered here, as all findings listed are those that Scout flagged.
+
+The following table summarizes the results by detector:
+
+| Detector                      | True Positives | False Positives | % False Positives |
+| ----------------------------- | -------------- | --------------- | ----------------- |
+| known_vulnerabilities         | 1              | 0               | 0%                |
+| avoid_panic_error             | 2              | 0               | 0%                |
+| avoid-dispatcherror-other     | 3              | 0               | 0%                |
+| assert_violation              | 7              | 0               | 0%                |
+| unsafe_expect                 | 0              | 17              | 100%              |
+| integer_overflow_or_underflow | 0              | 5               | 100%              |
+
+As shown above, while several detectors produced valid results with no false positives, others—particularly `unsafe_expect` and `integer_overflow_or_underflow`—yielded a high number of false positives. This insight helps guide future improvements to the detectors, aiming to reduce incorrect alerts and improve the overall reliability of Scout.
+
+## 4. Conclusion
+
+This precision and recall exercise is a critical component in refining Scout’s capabilities as we progress through Milestone 2 of our project. By running the tool against a variety of audited and unaudited projects, we have identified both the technical barriers—such as compilation errors and environmental setup issues—and the areas where our detectors need further refinement to minimize false positives and misclassifications.
+
+The results obtained here will inform the development of new detectors, improvements to existing ones, and enhancements to the supporting frameworks for analysis. Addressing these early findings will significantly improve Scout’s usability, ensuring that developers and auditors can rely on its insights. Ultimately, by identifying precision and environment-related issues now, we are setting a strong foundation for the subsequent milestones, which will deliver a more robust and accurate tool.