git.delta.rocks / unique-network / refs/commits / e2559ac16227

--- a/crates/evm-coder/procedural/src/solidity_interface.rs
+++ b/crates/evm-coder/procedural/src/solidity_interface.rs
@@ -404,7 +404,11 @@
 		let name = &self.name;
 		let ty = &self.ty;
 		quote! {
-			#name: <#ty>::abi_read(reader)?
+			#name: {
+				let value = <#ty as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
+				if !is_dynamic {reader.seek(<#ty as ::evm_coder::abi::AbiType>::size())};
+				value
+			}
 		}
 	}
 
@@ -630,17 +634,18 @@
 		let pascal_name = &self.pascal_name;
 		let screaming_name = &self.screaming_name;
 		if self.has_normal_args {
-			let parsers = self
-				.args
-				.iter()
-				.filter(|a| !a.is_special())
-				.map(|a| a.expand_parse());
+			let args_iter = self.args.iter().filter(|a| !a.is_special());
+			let arg_type = args_iter.clone().map(|a| &a.ty);
+			let parsers = args_iter.map(|a| a.expand_parse());
 			quote! {
-				Self::#screaming_name => return Ok(Some(Self::#pascal_name {
-					#(
-						#parsers,
-					)*
-				}))
+				Self::#screaming_name => {
+					let is_dynamic = false #(|| <#arg_type as ::evm_coder::abi::AbiType>::is_dynamic())*;
+					return Ok(Some(Self::#pascal_name {
+						#(
+							#parsers,
+						)*
+					}))
+				}
 			}
 		} else {
 			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }

262262
263		impl<$($ident),+> AbiRead for ($($ident,)+)263		impl<$($ident),+> AbiRead for ($($ident,)+)
264		where264		where
265			Self: AbiType,
265			$($ident: AbiRead + AbiType,)+266			$($ident: AbiRead + AbiType,)+
266			($($ident,)+): AbiType,
267		{267		{
268			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {268			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
269				let is_dynamic = <($($ident,)+)>::is_dynamic();269				let is_dynamic = <Self>::is_dynamic();
270				let size = if !is_dynamic { Some(<($($ident,)+)>::size()) } else { None };270				let size = if !is_dynamic { Some(<Self>::size()) } else { None };
271				let mut subresult = reader.subresult(size)?;271				let mut subresult = reader.subresult(size)?;
272				Ok((272				Ok((
273					$({273					$({

--- a/crates/evm-coder/src/abi/test.rs
+++ b/crates/evm-coder/src/abi/test.rs
@@ -450,6 +450,24 @@
 }
 
 #[test]
+fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {
+	test_impl::<((u8, u8), (u8, u8), u8)>(
+		0xdeadbeef,
+		((10, 11), (12, 13), 14),
+		&hex!(
+			"
+                deadbeef
+                000000000000000000000000000000000000000000000000000000000000000a
+                000000000000000000000000000000000000000000000000000000000000000b
+                000000000000000000000000000000000000000000000000000000000000000c
+                000000000000000000000000000000000000000000000000000000000000000d
+                000000000000000000000000000000000000000000000000000000000000000e
+            "
+		),
+	);
+}
+
+#[test]
 fn encode_decode_tuple0_tuple1_string() {
 	test_impl::<((String,),)>(
 		0xdeadbeef,
@@ -525,3 +543,19 @@
 		),
 	);
 }
+
+#[test]
+fn parse_multiple_params() {
+	let encoded_data = hex!(
+		"
+            deadbeef
+            000000000000000000000000000000000000000000000000000000000000000a
+            000000000000000000000000000000000000000000000000000000000000000b
+        "
+	);
+	let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();
+	let p1 = <u8>::abi_read(&mut decoder).unwrap();
+	let p2 = <u8>::abi_read(&mut decoder).unwrap();
+	assert_eq!(p1, 0x0a);
+	assert_eq!(p2, 0x0b);
+}

--- a/crates/evm-coder/tests/abi_derive_generation.rs
+++ b/crates/evm-coder/tests/abi_derive_generation.rs
@@ -619,3 +619,35 @@
 		},
 	);
 }
+
+#[derive(AbiCoder, PartialEq, Debug)]
+struct TypeStruct2SimpleStruct1Simple {
+	_a: TypeStruct2SimpleParam,
+	_b: TypeStruct2SimpleParam,
+	_c: u8,
+}
+#[derive(AbiCoder, PartialEq, Debug)]
+struct TupleStruct2SimpleStruct1Simple(TupleStruct2SimpleParam, TupleStruct2SimpleParam, u8);
+
+#[test]
+fn codec_struct_2_struct_simple_1_simple() {
+	let _a = 0xff;
+	let _b = 0xbeefbaba;
+	test_impl::<
+		((u8, u32), (u8, u32), u8),
+		TupleStruct2SimpleStruct1Simple,
+		TypeStruct2SimpleStruct1Simple,
+	>(
+		((_a, _b), (_a, _b), _a),
+		TupleStruct2SimpleStruct1Simple(
+			TupleStruct2SimpleParam(_a, _b),
+			TupleStruct2SimpleParam(_a, _b),
+			_a,
+		),
+		TypeStruct2SimpleStruct1Simple {
+			_a: TypeStruct2SimpleParam { _a, _b },
+			_b: TypeStruct2SimpleParam { _a, _b },
+			_c: _a,
+		},
+	);
+}