git.delta.rocks / unique-network / refs/commits / 7eec33a3cc63

--- a/crates/evm-coder/procedural/src/abi_derive.rs
+++ b/crates/evm-coder/procedural/src/abi_derive.rs
@@ -1,7 +1,6 @@
 use quote::quote;
 
 pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
-	// dbg!(ast);
 	let name = &ast.ident;
 	let (is_named_fields, field_names, field_types, params_count) = match &ast.data {
 		syn::Data::Struct(ds) => match ds.fields {
@@ -31,7 +30,7 @@
 	let abi_type = impl_abi_type(name, field_types.clone());
 	let abi_read = impl_abi_read(name, is_named_fields, field_names.clone(), field_types);
 	let abi_write = impl_abi_write(name, is_named_fields, params_count, field_names);
-	println!("{}", abi_write);
+
 	Ok(quote! {
 		#can_be_plcaed_in_vec
 		#abi_type
@@ -112,14 +111,19 @@
 	quote!(
 		impl ::evm_coder::abi::AbiRead for #name {
 			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {
-				let size = if !<Self as ::evm_coder::abi::AbiType>::is_dynamic() {
+				let is_dynamic = <Self as ::evm_coder::abi::AbiType>::is_dynamic();
+				let size = if !is_dynamic {
 					Some(<Self as ::evm_coder::abi::AbiType>::size())
 				} else {
 					None
 				};
 				let mut subresult = reader.subresult(size)?;
 				#(
-					let #field_names = <#field_types as ::evm_coder::abi::AbiRead>::abi_read(&mut subresult)?;
+					let #field_names = {
+						let value = <#field_types as ::evm_coder::abi::AbiRead>::abi_read(&mut subresult)?;
+						if !is_dynamic {subresult.seek(<#field_types as ::evm_coder::abi::AbiType>::size())};
+						value
+					};
 				)*
 
 				#struct_constructor

--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -92,7 +92,7 @@
 	}
 }
 
-impl<R: AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {
+impl<R: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {
 	fn abi_read(reader: &mut AbiReader) -> Result<Vec<R>> {
 		let mut sub = reader.subresult(None)?;
 		let size = sub.uint32()? as usize;
@@ -100,6 +100,9 @@
 		let mut out = Vec::with_capacity(size);
 		for _ in 0..size {
 			out.push(<R>::abi_read(&mut sub)?);
+			if !<R>::is_dynamic() {
+				sub.subresult_offset += <R>::size()
+			};
 		}
 		Ok(out)
 	}
@@ -295,14 +298,19 @@
 
 		impl<$($ident),+> AbiRead for ($($ident,)+)
 		where
-			$($ident: AbiRead,)+
+			$($ident: AbiRead + AbiType,)+
 			($($ident,)+): AbiType,
 		{
 			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
-				let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };
+				let is_dynamic = <($($ident,)+)>::is_dynamic();
+				let size = if !is_dynamic { Some(<($($ident,)+)>::size()) } else { None };
 				let mut subresult = reader.subresult(size)?;
 				Ok((
-					$(<$ident>::abi_read(&mut subresult)?,)+
+					$({
+						let value = <$ident>::abi_read(&mut subresult)?;
+						if !is_dynamic {subresult.seek(<$ident as AbiType>::size())};
+						value
+					},)+
 				))
 			}
 		}

--- a/crates/evm-coder/src/abi/mod.rs
+++ b/crates/evm-coder/src/abi/mod.rs
@@ -75,19 +75,19 @@
 		buf: &[u8],
 		offset: usize,
 		pad_start: usize,
-		pad_size: usize,
+		pad_end: usize,
 		block_start: usize,
-		block_size: usize,
+		block_end: usize,
 	) -> Result<[u8; S]> {
 		if buf.len() - offset < ABI_ALIGNMENT {
 			return Err(Error::Error(ExitError::OutOfOffset));
 		}
 		let mut block = [0; S];
-		let is_pad_zeroed = buf[pad_start..pad_size].iter().all(|&v| v == 0);
+		let is_pad_zeroed = buf[pad_start..pad_end].iter().all(|&v| v == 0);
 		if !is_pad_zeroed {
 			return Err(Error::Error(ExitError::InvalidRange));
 		}
-		block.copy_from_slice(&buf[block_start..block_size]);
+		block.copy_from_slice(&buf[block_start..block_end]);
 		Ok(block)
 	}
 
@@ -190,7 +190,6 @@
 		let subresult_offset = self.subresult_offset;
 		let offset = if let Some(size) = size {
 			self.offset += size;
-			self.subresult_offset += size;
 			0
 		} else {
 			self.uint32()? as usize
@@ -208,6 +207,11 @@
 		})
 	}
 
+	/// Notify about readed data portion.
+	pub fn seek(&mut self, size: usize) {
+		self.subresult_offset += size;
+	}
+
 	/// Is this parser reached end of buffer?
 	pub fn is_finished(&self) -> bool {
 		self.buf.len() == self.offset

136    );136    );
137}137}
138
139#[test]
140fn encode_decode_vec_tuple_uint8_uint8() {
141	test_impl::<Vec<(u8, u8)>>(
142		0xdeadbeef,
143		vec![(0x0A, 0x0B), (0x0C, 0x0D), (0x0E, 0x0F)],
144		&hex!(
145			"
146                deadbeef
147                0000000000000000000000000000000000000000000000000000000000000020
148                0000000000000000000000000000000000000000000000000000000000000003
149                000000000000000000000000000000000000000000000000000000000000000a
150                000000000000000000000000000000000000000000000000000000000000000b
151                000000000000000000000000000000000000000000000000000000000000000c
152                000000000000000000000000000000000000000000000000000000000000000d
153                000000000000000000000000000000000000000000000000000000000000000e
154                000000000000000000000000000000000000000000000000000000000000000f
155            "
156		),
157	);
158}
138159
139#[test]160#[test]
140fn encode_decode_vec_tuple_uint256_string() {161fn encode_decode_vec_tuple_uint256_string() {
333	);354	);
334}355}
356
357#[test]
358// #[ignore = "reason"]
359fn encode_decode_tuple0_tuple1_uint8_tuple1_string_bytes_tuple1_uint8_bytes() {
360	let int = 0xff;
361	let by = bytes(vec![0x11, 0x22, 0x33]);
362	let string = "some string".to_string();
363
364	test_impl::<((u8,), (String, bytes), (u8, bytes))>(
365		0xdeadbeef,
366		((int,), (string.clone(), by.clone()), (int, by)),
367		&hex!(
368			"
369                deadbeef
370                0000000000000000000000000000000000000000000000000000000000000020
371                00000000000000000000000000000000000000000000000000000000000000ff
372                0000000000000000000000000000000000000000000000000000000000000060
373                0000000000000000000000000000000000000000000000000000000000000120
374                0000000000000000000000000000000000000000000000000000000000000040
375                0000000000000000000000000000000000000000000000000000000000000080
376                000000000000000000000000000000000000000000000000000000000000000b
377                736f6d6520737472696e67000000000000000000000000000000000000000000
378                0000000000000000000000000000000000000000000000000000000000000003
379                1122330000000000000000000000000000000000000000000000000000000000
380                00000000000000000000000000000000000000000000000000000000000000ff
381                0000000000000000000000000000000000000000000000000000000000000040
382                0000000000000000000000000000000000000000000000000000000000000003
383                1122330000000000000000000000000000000000000000000000000000000000
384            "
385		),
386	);
387}
388
389#[test]
390fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8_uint8_tuple1_uint8_uint8() {
391	test_impl::<((u8,), (u8, u8), (u8, u8))>(
392		0xdeadbeef,
393		((43,), (44, 45), (46, 47)),
394		&hex!(
395			"
396                deadbeef
397                000000000000000000000000000000000000000000000000000000000000002b
398                000000000000000000000000000000000000000000000000000000000000002c
399                000000000000000000000000000000000000000000000000000000000000002d
400                000000000000000000000000000000000000000000000000000000000000002e
401                000000000000000000000000000000000000000000000000000000000000002f
402            "
403		),
404	);
405}
406
407#[test]
408fn encode_decode_tuple0_tuple1_uint8_tuple1_uint8() {
409	test_impl::<((u8,), (u8,))>(
410		0xdeadbeef,
411		((43,), (44,)),
412		&hex!(
413			"
414                deadbeef
415                000000000000000000000000000000000000000000000000000000000000002b
416                000000000000000000000000000000000000000000000000000000000000002c
417            "
418		),
419	);
420}
421
422#[test]
423fn encode_decode_tuple0_tuple1_uint8_uint8() {
424	test_impl::<((u8, u8),)>(
425		0xdeadbeef,
426		((43, 44),),
427		&hex!(
428			"
429                deadbeef
430                000000000000000000000000000000000000000000000000000000000000002b
431                000000000000000000000000000000000000000000000000000000000000002c
432            "
433		),
434	);
435}
436
437#[test]
438fn encode_decode_tuple_uint8_uint8() {
439	test_impl::<(u8, u8)>(
440		0xdeadbeef,
441		(43, 44),
442		&hex!(
443			"
444                deadbeef
445                000000000000000000000000000000000000000000000000000000000000002b
446                000000000000000000000000000000000000000000000000000000000000002c
447            "
448		),
449	);
450}
451
452#[test]
453fn encode_decode_tuple0_tuple1_string() {
454	test_impl::<((String,),)>(
455		0xdeadbeef,
456		(("some string".to_string(),),),
457		&hex!(
458			"
459                deadbeef
460                0000000000000000000000000000000000000000000000000000000000000020
461                0000000000000000000000000000000000000000000000000000000000000020
462                0000000000000000000000000000000000000000000000000000000000000020
463                000000000000000000000000000000000000000000000000000000000000000b
464                736f6d6520737472696e67000000000000000000000000000000000000000000
465            "
466		),
467	);
468}
469
470#[test]
471fn encode_decode_tuple0_tuple1_uint8_string() {
472	test_impl::<((u8, String),)>(
473		0xdeadbeef,
474		((0xff, "some string".to_string()),),
475		&hex!(
476			"
477                deadbeef
478                0000000000000000000000000000000000000000000000000000000000000020
479                0000000000000000000000000000000000000000000000000000000000000020
480                00000000000000000000000000000000000000000000000000000000000000ff
481                0000000000000000000000000000000000000000000000000000000000000040
482                000000000000000000000000000000000000000000000000000000000000000b
483                736f6d6520737472696e67000000000000000000000000000000000000000000
484            "
485		),
486	);
487}
488
489#[test]
490fn encode_decode_tuple0_tuple1_string_bytes() {
491	test_impl::<((String, bytes),)>(
492		0xdeadbeef,
493		(("some string".to_string(), bytes(vec![1, 2, 3])),),
494		&hex!(
495			"
496                deadbeef
497                0000000000000000000000000000000000000000000000000000000000000020
498                0000000000000000000000000000000000000000000000000000000000000020
499                0000000000000000000000000000000000000000000000000000000000000040
500                0000000000000000000000000000000000000000000000000000000000000080
501                000000000000000000000000000000000000000000000000000000000000000b
502                736f6d6520737472696e67000000000000000000000000000000000000000000
503                0000000000000000000000000000000000000000000000000000000000000003
504                0102030000000000000000000000000000000000000000000000000000000000
505            "
506		),
507	);
508}
509
510#[test]
511fn encode_decode_tuple0_tuple1_uint8_tuple1_string() {
512	test_impl::<((u8,), (String,))>(
513		0xdeadbeef,
514		((0xff,), ("some string".to_string(),)),
515		&hex!(
516			"
517                deadbeef
518                0000000000000000000000000000000000000000000000000000000000000020
519                00000000000000000000000000000000000000000000000000000000000000ff
520                0000000000000000000000000000000000000000000000000000000000000040
521                0000000000000000000000000000000000000000000000000000000000000020
522                000000000000000000000000000000000000000000000000000000000000000b
523                736f6d6520737472696e67000000000000000000000000000000000000000000
524            "
525		),
526	);
527}
335528

--- a/crates/evm-coder/tests/abi_derive_generation.rs
+++ b/crates/evm-coder/tests/abi_derive_generation.rs
@@ -1,7 +1,7 @@
 use evm_coder_procedural::AbiCoder;
 use evm_coder::{
 	types::*,
-	abi::{AbiType, AbiRead, AbiWrite},
+	abi::{AbiType, AbiRead, AbiWrite, AbiReader, AbiWriter},
 };
 
 // TODO: move to build_failed tests
@@ -406,66 +406,199 @@
 	);
 }
 
-fn test_impl<TypeStruct, TupleStruct, Tuple>(
-	type_struct_data: TypeStruct,
-	tuple_struct_data: TupleStruct,
+const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
+
+fn test_impl<Tuple, TupleStruct, TypeStruct>(
 	tuple_data: Tuple,
+	tuple_struct_data: TupleStruct,
+	type_struct_data: TypeStruct,
 ) where
 	TypeStruct: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
+	TupleStruct: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
 	Tuple: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
 {
-	use evm_coder::abi::{AbiReader, AbiWriter};
-	const FUNCTION_IDENTIFIER: u32 = 0xdeadbeef;
+	let encoded_type_struct = test_abi_write_impl(&type_struct_data);
+	let encoded_tuple_struct = test_abi_write_impl(&tuple_struct_data);
+	let encoded_tuple = test_abi_write_impl(&tuple_data);
 
-	let mut writer = AbiWriter::new_call(FUNCTION_IDENTIFIER);
-	tuple_data.abi_write(&mut writer);
-	let encoded_tuple = writer.finish();
+	similar_asserts::assert_eq!(encoded_tuple, encoded_type_struct);
+	similar_asserts::assert_eq!(encoded_tuple, encoded_tuple_struct);
 
-	let mut writer = AbiWriter::new_call(FUNCTION_IDENTIFIER);
-	type_struct_data.abi_write(&mut writer);
-	let encoded_struct = writer.finish();
+	// dbg!(&encoded_tuple);
+	// dbg!(&encoded_tuple_struct);
+	// dbg!(&encoded_type_struct);
 
-	similar_asserts::assert_eq!(encoded_tuple, encoded_struct);
+	{
+		let (_, mut decoder) = AbiReader::new_call(&encoded_tuple).unwrap();
+		let restored_struct_data = <TypeStruct>::abi_read(&mut decoder).unwrap();
+		assert_eq!(restored_struct_data, type_struct_data);
+	}
+	{
+		let (_, mut decoder) = AbiReader::new_call(&encoded_tuple).unwrap();
+		let restored_struct_data = <TupleStruct>::abi_read(&mut decoder).unwrap();
+		assert_eq!(restored_struct_data, tuple_struct_data);
+	}
 
-	// let (_, mut decoder) = AbiReader::new_call(&encoded_tuple).unwrap();
-	// let restored_struct_data = <TypeStruct>::abi_read(&mut decoder).unwrap();
-	// assert_eq!(restored_struct_data, type_struct_data);
+	{
+		let (_, mut decoder) = AbiReader::new_call(&encoded_type_struct).unwrap();
+		let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
+		assert_eq!(restored_tuple_data, tuple_data);
+	}
+	{
+		let (_, mut decoder) = AbiReader::new_call(&encoded_tuple_struct).unwrap();
+		let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
+		assert_eq!(restored_tuple_data, tuple_data);
+	}
+}
 
-	// let (_, mut decoder) = AbiReader::new_call(&encoded_struct).unwrap();
-	// let restored_tuple_data = <Tuple>::abi_read(&mut decoder).unwrap();
-	// assert_eq!(restored_tuple_data, tuple_data);
+fn test_abi_write_impl<A>(data: &A) -> Vec<u8>
+where
+	A: AbiWrite + AbiRead + std::cmp::PartialEq + std::fmt::Debug,
+{
+	let mut writer = AbiWriter::new_call(FUNCTION_IDENTIFIER);
+	data.abi_write(&mut writer);
+	let encoded_tuple = writer.finish();
+	encoded_tuple
 }
 
 #[test]
 fn codec_struct_1_simple() {
 	let _a = 0xff;
-	test_impl::<TypeStruct1SimpleParam, TupleStruct1SimpleParam, (uint8,)>(
-		TypeStruct1SimpleParam { _a },
+	test_impl::<(uint8,), TupleStruct1SimpleParam, TypeStruct1SimpleParam>(
+		(_a,),
 		TupleStruct1SimpleParam(_a),
-		(_a,),
+		TypeStruct1SimpleParam { _a },
 	);
 }
 
 #[test]
 fn codec_struct_1_dynamic() {
 	let _a: String = "some string".into();
-	test_impl::<TypeStruct1DynamicParam, TupleStruct1DynamicParam, (String,)>(
-		TypeStruct1DynamicParam { _a: _a.clone() },
+	test_impl::<(String,), TupleStruct1DynamicParam, TypeStruct1DynamicParam>(
+		(_a.clone(),),
 		TupleStruct1DynamicParam(_a.clone()),
-		(_a,),
+		TypeStruct1DynamicParam { _a },
+	);
+}
+
+#[test]
+fn codec_struct_1_derived_simple() {
+	let _a: u8 = 0xff;
+	test_impl::<((u8,),), TupleStruct1DerivedSimpleParam, TypeStruct1DerivedSimpleParam>(
+		((_a,),),
+		TupleStruct1DerivedSimpleParam(TupleStruct1SimpleParam(_a)),
+		TypeStruct1DerivedSimpleParam {
+			_a: TypeStruct1SimpleParam { _a },
+		},
 	);
 }
 
 #[test]
+fn codec_struct_1_derived_dynamic() {
+	let _a: String = "some string".into();
+	test_impl::<((String,),), TupleStruct1DerivedDynamicParam, TypeStruct1DerivedDynamicParam>(
+		((_a.clone(),),),
+		TupleStruct1DerivedDynamicParam(TupleStruct1DynamicParam(_a.clone())),
+		TypeStruct1DerivedDynamicParam {
+			_a: TypeStruct1DynamicParam { _a },
+		},
+	);
+}
+
+#[test]
+fn codec_struct_2_simple() {
+	let _a = 0xff;
+	let _b = 0xbeefbaba;
+	test_impl::<(u8, u32), TupleStruct2SimpleParam, TypeStruct2SimpleParam>(
+		(_a, _b),
+		TupleStruct2SimpleParam(_a, _b),
+		TypeStruct2SimpleParam { _a, _b },
+	);
+}
+
+#[test]
 fn codec_struct_2_dynamic() {
 	let _a: String = "some string".into();
 	let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
-	test_impl::<TypeStruct2DynamicParam, TupleStruct2DynamicParam, (String, bytes)>(
-		TypeStruct2DynamicParam {
-			_a: _a.clone(),
-			_b: _b.clone(),
-		},
+	test_impl::<(String, bytes), TupleStruct2DynamicParam, TypeStruct2DynamicParam>(
+		(_a.clone(), _b.clone()),
 		TupleStruct2DynamicParam(_a.clone(), _b.clone()),
-		(_a, _b),
+		TypeStruct2DynamicParam { _a, _b },
+	);
+}
+
+#[test]
+fn codec_struct_2_mixed() {
+	let _a: u8 = 0xff;
+	let _b: bytes = bytes(vec![0x11, 0x22, 0x33]);
+	test_impl::<(u8, bytes), TupleStruct2MixedParam, TypeStruct2MixedParam>(
+		(_a.clone(), _b.clone()),
+		TupleStruct2MixedParam(_a.clone(), _b.clone()),
+		TypeStruct2MixedParam { _a, _b },
+	);
+}
+
+#[test]
+fn codec_struct_2_derived_simple() {
+	let _a = 0xff;
+	let _b = 0xbeefbaba;
+	test_impl::<((u8,), (u8, u32)), TupleStruct2DerivedSimpleParam, TypeStruct2DerivedSimpleParam>(
+		((_a,), (_a, _b)),
+		TupleStruct2DerivedSimpleParam(
+			TupleStruct1SimpleParam(_a),
+			TupleStruct2SimpleParam(_a, _b),
+		),
+		TypeStruct2DerivedSimpleParam {
+			_a: TypeStruct1SimpleParam { _a },
+			_b: TypeStruct2SimpleParam { _a, _b },
+		},
+	);
+}
+
+#[test]
+fn codec_struct_2_derived_dynamic() {
+	let _a = "some string".to_string();
+	let _b = bytes(vec![0x11, 0x22, 0x33]);
+	test_impl::<
+		((String,), (String, bytes)),
+		TupleStruct2DerivedDynamicParam,
+		TypeStruct2DerivedDynamicParam,
+	>(
+		((_a.clone(),), (_a.clone(), _b.clone())),
+		TupleStruct2DerivedDynamicParam(
+			TupleStruct1DynamicParam(_a.clone()),
+			TupleStruct2DynamicParam(_a.clone(), _b.clone()),
+		),
+		TypeStruct2DerivedDynamicParam {
+			_a: TypeStruct1DynamicParam { _a: _a.clone() },
+			_b: TypeStruct2DynamicParam { _a, _b },
+		},
+	);
+}
+
+#[test]
+fn codec_struct_3_derived_mixed() {
+	let int = 0xff;
+	let by = bytes(vec![0x11, 0x22, 0x33]);
+	let string = "some string".to_string();
+	test_impl::<
+		((u8,), (String, bytes), (u8, bytes)),
+		TupleStruct3DerivedMixedParam,
+		TypeStruct3DerivedMixedParam,
+	>(
+		((int,), (string.clone(), by.clone()), (int, by.clone())),
+		TupleStruct3DerivedMixedParam(
+			TupleStruct1SimpleParam(int),
+			TupleStruct2DynamicParam(string.clone(), by.clone()),
+			TupleStruct2MixedParam(int, by.clone()),
+		),
+		TypeStruct3DerivedMixedParam {
+			_a: TypeStruct1SimpleParam { _a: int },
+			_b: TypeStruct2DynamicParam {
+				_a: string.clone(),
+				_b: by.clone(),
+			},
+			_c: TypeStruct2MixedParam { _a: int, _b: by },
+		},
 	);
 }