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)) }

--- 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((
 					$({

449	);449	);
450}450}
451
452#[test]
453fn encode_decode_tuple0_tuple1_uint8_uint8_tuple1_uint8_uint8_and_uint8() {
454	test_impl::<((u8, u8), (u8, u8), u8)>(
455		0xdeadbeef,
456		((10, 11), (12, 13), 14),
457		&hex!(
458			"
459                deadbeef
460                000000000000000000000000000000000000000000000000000000000000000a
461                000000000000000000000000000000000000000000000000000000000000000b
462                000000000000000000000000000000000000000000000000000000000000000c
463                000000000000000000000000000000000000000000000000000000000000000d
464                000000000000000000000000000000000000000000000000000000000000000e
465            "
466		),
467	);
468}
451469
452#[test]470#[test]
453fn encode_decode_tuple0_tuple1_string() {471fn encode_decode_tuple0_tuple1_string() {
526	);544	);
527}545}
546
547#[test]
548fn parse_multiple_params() {
549	let encoded_data = hex!(
550		"
551            deadbeef
552            000000000000000000000000000000000000000000000000000000000000000a
553            000000000000000000000000000000000000000000000000000000000000000b
554        "
555	);
556	let (_, mut decoder) = AbiReader::new_call(&encoded_data).unwrap();
557	let p1 = <u8>::abi_read(&mut decoder).unwrap();
558	let p2 = <u8>::abi_read(&mut decoder).unwrap();
559	assert_eq!(p1, 0x0a);
560	assert_eq!(p2, 0x0b);
561}
528562

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