env: Fix SolEncode implementation for ArgumentList

davidsemakula · davidsemakula · commit 87db54b9d549 · 2025-06-25T17:57:04.000+03:00
diff --git a/crates/env/src/call/execution.rs b/crates/env/src/call/execution.rs
@@ -345,23 +345,77 @@ impl SolEncode<'_> for EmptyArgumentList<Sol> {
     fn to_sol_type(&self) {}
 }
 
-impl<'a, Head, Rest> SolEncode<'a> for ArgumentList<Argument<Head>, Rest, Sol>
+impl<Head, Rest> SolEncode<'_> for ArgumentList<Argument<Head>, Rest, Sol>
 where
-    Head: SolEncode<'a>,
-    Rest: SolEncode<'a>,
+    Self: SolEncodeArgsList,
 {
-    type SolType = (Rest::SolType, Head::SolType);
+    // NOTE: Not actually used for encoding because of `encode` override below.
+    type SolType = ();
 
-    fn encode(&'a self) -> Vec<u8> {
-        let mut encoded = Vec::new();
-        encoded.extend(Rest::encode(&self.rest));
-        encoded.extend(Head::encode(&self.head.arg));
-        encoded
+    fn encode(&self) -> Vec<u8> {
+        let mut encoded_args_info = Vec::new();
+        // Collects encoding info for each arg in `Argument list`.
+        let mut offset = self.encode_args(&mut encoded_args_info);
+        let mut head = Vec::new();
+        let mut tail = Vec::<u8>::new();
+
+        // Composes the head and tail parts of the parameter encoding.
+        // Ref: <https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector-and-argument-encoding>
+        for (dynamic, encoded) in encoded_args_info {
+            if dynamic {
+                head.extend(SolEncode::encode(&(offset as u128)));
+                // Standalone encoding for dynamic types includes a 32 bytes offset.
+                let data = &encoded[32..];
+                offset += data.len();
+                tail.extend(data);
+            } else {
+                head.extend(encoded);
+            }
+        }
+
+        head.extend(tail);
+        head
     }
 
-    fn to_sol_type(&'a self) -> Self::SolType {
-        // NOTE: Not actually used for encoding because of `encode` override above.
-        (self.rest.to_sol_type(), self.head.arg.to_sol_type())
+    // NOTE: Not actually used for encoding because of `encode` override above.
+    fn to_sol_type(&self) {}
+}
+
+/// Helper trait for Solidity ABI encoding `ArgumentList`.
+trait SolEncodeArgsList {
+    /// Solidity ABI encodes each arg in `ArgumentList`,
+    /// and returns the `offset` for dynamic data for the entire argument list.
+    ///
+    /// Ref: <https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector-and-argument-encoding>
+    fn encode_args(&self, results: &mut Vec<(bool, Vec<u8>)>) -> usize;
+}
+
+impl SolEncodeArgsList for EmptyArgumentList<Sol> {
+    fn encode_args(&self, _: &mut Vec<(bool, Vec<u8>)>) -> usize {
+        0
+    }
+}
+
+impl<Head, Rest> SolEncodeArgsList for ArgumentList<Argument<Head>, Rest, Sol>
+where
+    Head: for<'a> SolEncode<'a>,
+    Rest: SolEncodeArgsList,
+{
+    fn encode_args(&self, results: &mut Vec<(bool, Vec<u8>)>) -> usize {
+        let mut offset = self.rest.encode_args(results);
+        let dynamic = <Head as SolEncode>::DYNAMIC;
+        let encoded = self.head.arg.encode();
+
+        if dynamic {
+            // Dynamic types are represented (in the head) by their offset,
+            // which is always 32 bytes long.
+            offset += 32;
+        } else {
+            offset += encoded.len();
+        }
+
+        results.push((dynamic, encoded));
+        offset
     }
 }
 
@@ -407,4 +461,20 @@ mod tests {
             <(i32, bool, [u8; 4]) as scale::Decode>::decode(&mut &encoded[..]).unwrap();
         assert_eq!(decoded, (42i32, true, [0x66; 4]));
     }
+
+    #[test]
+    fn sol_encoding_arguments_works() {
+        let args_list = EmptyArgumentList::<Sol>::empty()
+            .push_arg(100u8)
+            .push_arg(vec![1, 2, 3, 4])
+            .push_arg(String::from("Hello, world!"))
+            .push_arg(true);
+        let encoded_args_list = SolEncode::encode(&args_list);
+
+        let args_tuple = (100u8, vec![1, 2, 3, 4], String::from("Hello, world!"), true);
+        let encoded_args_tuple =
+            ink_primitives::sol::SolParamsEncode::encode(&args_tuple);
+
+        assert_eq!(encoded_args_list, encoded_args_tuple);
+    }
 }
