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

404		let name = &self.name;404		let name = &self.name;
405		let ty = &self.ty;405		let ty = &self.ty;
406		quote! {406		quote! {
407			#name: <#ty>::abi_read(reader)?407			#name: {
408				let value = <#ty as ::evm_coder::abi::AbiRead>::abi_read(reader)?;
409				if !is_dynamic {reader.seek(<#ty as ::evm_coder::abi::AbiType>::size())};
410				value
411			}
408		}412		}
409	}413	}
410414
630		let pascal_name = &self.pascal_name;634		let pascal_name = &self.pascal_name;
631		let screaming_name = &self.screaming_name;635		let screaming_name = &self.screaming_name;
632		if self.has_normal_args {636		if self.has_normal_args {
633			let parsers = self637			let args_iter = self.args.iter().filter(|a| !a.is_special());
634				.args638			let arg_type = args_iter.clone().map(|a| &a.ty);
635				.iter()
636				.filter(|a| !a.is_special())
637				.map(|a| a.expand_parse());639			let parsers = args_iter.map(|a| a.expand_parse());
638			quote! {640			quote! {
639				Self::#screaming_name => return Ok(Some(Self::#pascal_name {641				Self::#screaming_name => {
642					let is_dynamic = false #(|| <#arg_type as ::evm_coder::abi::AbiType>::is_dynamic())*;
643					return Ok(Some(Self::#pascal_name {
640					#(644						#(
641						#parsers,645							#parsers,
642					)*646						)*
643				}))647					}))
648				}
644			}649			}
645		} else {650		} else {
646			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }651			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }

--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -262,12 +262,12 @@
 
 		impl<$($ident),+> AbiRead for ($($ident,)+)
 		where
+			Self: AbiType,
 			$($ident: AbiRead + AbiType,)+
-			($($ident,)+): AbiType,
 		{
 			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
-				let is_dynamic = <($($ident,)+)>::is_dynamic();
-				let size = if !is_dynamic { Some(<($($ident,)+)>::size()) } else { None };
+				let is_dynamic = <Self>::is_dynamic();
+				let size = if !is_dynamic { Some(<Self>::size()) } else { None };
 				let mut subresult = reader.subresult(size)?;
 				Ok((
 					$({

--- 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,
+		},
+	);
+}