Add DispatchInfo tests

primitives/src/precompiles.rs

@@ -27,8 +27,7 @@ use frame_support::{
 };
 use pallet_evm_precompile_dispatch::DispatchValidateT;
 
-/// Struct that allows only whitelisted runtime calls to pass through dispatch precompile,
-/// Whitelisted calls are defined in runtime
+/// Struct that allows only calls based on `Filter` to pass through.
 pub struct DispatchFilterValidate<RuntimeCall, Filter: Contains<RuntimeCall>>(
     PhantomData<(RuntimeCall, Filter)>,
 );

tests/integration/Cargo.toml

@@ -34,6 +34,7 @@ sp-runtime = { workspace = true }
 # astar dependencies
 pallet-ethereum-checked = { workspace = true }
 pallet-evm-precompile-assets-erc20 = { workspace = true }
+pallet-evm-precompile-dispatch = { workspace = true }
 precompile-utils = { workspace = true }
 
 astar-primitives = { workspace = true }

tests/integration/src/dispatch_precompile_filter.rs

@@ -18,7 +18,13 @@
 #![cfg(test)]
 
 use crate::setup::*;
-use frame_support::traits::Contains;
+use astar_primitives::precompiles::DispatchFilterValidate;
+use fp_evm::{ExitError, PrecompileFailure};
+use frame_support::{
+    dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays},
+    traits::Contains,
+};
+use pallet_evm_precompile_dispatch::DispatchValidateT;
 
 /// Whitelisted Calls are defined in the runtime
 #[test]
@@ -106,3 +112,90 @@ fn filter_accepts_whitelisted_batch_all_calls() {
         assert!(WhitelistedCalls::contains(&call));
     });
 }
+
+#[test]
+fn test_correct_dispatch_info_works() {
+    ExtBuilder::default().build().execute_with(|| {
+        // Mock implementation
+        struct Filter;
+        struct AccountId;
+        enum RuntimeCall {
+            System,
+            DappsStaking,
+        }
+        impl GetDispatchInfo for RuntimeCall {
+            fn get_dispatch_info(&self) -> DispatchInfo {
+                // Default is Pays::Yes and DispatchCall::Normal
+                DispatchInfo::default()
+            }
+        }
+        impl Contains<RuntimeCall> for Filter {
+            fn contains(t: &RuntimeCall) -> bool {
+                match t {
+                    RuntimeCall::DappsStaking => true,
+                    _ => false,
+                }
+            }
+        }
+        // Case 1: Whitelisted Call with correct Dispatch info
+        assert_eq!(
+            DispatchFilterValidate::<RuntimeCall, Filter>::validate_before_dispatch(
+                &AccountId,
+                &RuntimeCall::DappsStaking
+            ),
+            Option::None
+        );
+        // Case 2: Non-Whitelisted Call with correct Dispatch Info
+        assert_eq!(
+            DispatchFilterValidate::<RuntimeCall, Filter>::validate_before_dispatch(
+                &AccountId,
+                &RuntimeCall::System
+            ),
+            Option::Some(PrecompileFailure::Error {
+                exit_status: ExitError::Other("call filtered out".into()),
+            })
+        );
+    });
+}
+
+#[test]
+fn test_incorrect_dispatch_info_fails() {
+    ExtBuilder::default().build().execute_with(|| {
+        // Mock implementation
+        struct Filter;
+        struct AccountId;
+        enum RuntimeCall {
+            System,
+            DappsStaking,
+        }
+        impl GetDispatchInfo for RuntimeCall {
+            fn get_dispatch_info(&self) -> DispatchInfo {
+                DispatchInfo {
+                    weight: Weight::default(),
+                    class: DispatchClass::Normal,
+                    // Should have been Pays::Yes for call to pass
+                    pays_fee: Pays::No,
+                }
+            }
+        }
+        impl Contains<RuntimeCall> for Filter {
+            fn contains(t: &RuntimeCall) -> bool {
+                match t {
+                    RuntimeCall::DappsStaking => true,
+                    _ => false,
+                }
+            }
+        }
+
+        // WhiteListed Call fails because of incorrect DispatchInfo
+        assert_eq!(
+            DispatchFilterValidate::<RuntimeCall, Filter>::validate_before_dispatch(
+                &AccountId,
+                &RuntimeCall::DappsStaking
+            ),
+            Option::Some(PrecompileFailure::Error {
+                exit_status: ExitError::Other("invalid call".into()),
+            })
+        );
+    })
+}