Fix/cast abi strict args (#11189)

* fix(encode-args-length mismatch): validate inputs length match args length before encode args

* feat(encode-args): add test to length validation

* feat(abi-encode): fit args validation error message and add validation for packaged abi encode

* chore: clippy

* fmt

---------

Co-authored-by: DaniPopes <[email protected]>

Author: simon0820s

crates/cast/src/lib.rs

@@ -1809,10 +1809,7 @@ impl SimpleCast {
         let func = get_func(sig)?;
         match encode_function_args(&func, args) {
             Ok(res) => Ok(hex::encode_prefixed(&res[4..])),
-            Err(e) => eyre::bail!(
-                "Could not ABI encode the function and arguments. Did you pass in the right types?\nError\n{}",
-                e
-            ),
+            Err(e) => eyre::bail!("Could not ABI encode the function and arguments: {e}"),
         }
     }
 
@@ -1842,10 +1839,7 @@ impl SimpleCast {
         let func = get_func(sig.as_str())?;
         let encoded = match encode_function_args_packed(&func, args) {
             Ok(res) => hex::encode(res),
-            Err(e) => eyre::bail!(
-                "Could not ABI encode the function and arguments. Did you pass in the right types?\nError\n{}",
-                e
-            ),
+            Err(e) => eyre::bail!("Could not ABI encode the function and arguments: {e}"),
         };
         Ok(format!("0x{encoded}"))
     }

crates/common/src/abi.rs

@@ -15,6 +15,12 @@ where
     I: IntoIterator<Item = S>,
     S: AsRef<str>,
 {
+    let args: Vec<S> = args.into_iter().collect();
+
+    if inputs.len() != args.len() {
+        eyre::bail!("encode length mismatch: expected {} types, got {}", inputs.len(), args.len())
+    }
+
     std::iter::zip(inputs, args)
         .map(|(input, arg)| coerce_value(&input.selector_type(), arg.as_ref()))
         .collect()
@@ -47,6 +53,16 @@ where
     I: IntoIterator<Item = S>,
     S: AsRef<str>,
 {
+    let args: Vec<S> = args.into_iter().collect();
+
+    if func.inputs.len() != args.len() {
+        eyre::bail!(
+            "encode length mismatch: expected {} types, got {}",
+            func.inputs.len(),
+            args.len(),
+        );
+    }
+
     let params: Vec<Vec<u8>> = std::iter::zip(&func.inputs, args)
         .map(|(input, arg)| coerce_value(&input.selector_type(), arg.as_ref()))
         .collect::<Result<Vec<_>>>()?
@@ -257,4 +273,43 @@ mod tests {
         assert_eq!(parsed.indexed[1], DynSolValue::Uint(U256::from_be_bytes([3; 32]), 256));
         assert_eq!(parsed.indexed[2], DynSolValue::Address(Address::from_word(param2)));
     }
+
+    #[test]
+    fn test_encode_args_length_validation() {
+        use alloy_json_abi::Param;
+
+        let params = vec![
+            Param {
+                name: "a".to_string(),
+                ty: "uint256".to_string(),
+                internal_type: None,
+                components: vec![],
+            },
+            Param {
+                name: "b".to_string(),
+                ty: "address".to_string(),
+                internal_type: None,
+                components: vec![],
+            },
+        ];
+
+        // Less arguments than parameters
+        let args = vec!["1"];
+        let res = encode_args(&params, &args);
+        assert!(res.is_err());
+        assert!(format!("{}", res.unwrap_err()).contains("encode length mismatch"));
+
+        // Exact number of arguments and parameters
+        let args = vec!["1", "0x0000000000000000000000000000000000000001"];
+        let res = encode_args(&params, &args);
+        assert!(res.is_ok());
+        let values = res.unwrap();
+        assert_eq!(values.len(), 2);
+
+        // More arguments than parameters
+        let args = vec!["1", "0x0000000000000000000000000000000000000001", "extra"];
+        let res = encode_args(&params, &args);
+        assert!(res.is_err());
+        assert!(format!("{}", res.unwrap_err()).contains("encode length mismatch"));
+    }
 }