git.delta.rocks / unique-network / refs/commits / 527498be3f5d

403	fn expand_parse(&self) -> proc_macro2::TokenStream {403	fn expand_parse(&self) -> proc_macro2::TokenStream {
404		assert!(!self.is_special());404		assert!(!self.is_special());
405		let name = &self.name;405		let name = &self.name;
406		let ty = &self.ty;
406		quote! {407		quote! {
407			#name: reader.abi_read()?408			#name: <#ty>::abi_read(reader)?
408		}409		}
409	}410	}
410411

342	}342	}
343}343}
344344
345/// [`AbiReader`] implements reading of many types, but it should345/// [`AbiReader`] implements reading of many types.
346/// be limited to types defined in spec
347///
348/// As this trait can't be made sealed,
349/// instead of having `impl AbiRead for T`, we have `impl AbiRead<T> for AbiReader`
350pub trait AbiRead<T> {346pub trait AbiRead {
351	/// Read item from current position, advanding decoder347	/// Read item from current position, advanding decoder
352	fn abi_read(&mut self) -> Result<T>;348	fn abi_read(reader: &mut AbiReader) -> Result<Self>
349	where
350		Self: Sized;
353}351}
354352
355macro_rules! impl_abi_readable {353macro_rules! impl_abi_readable {
363				ABI_ALIGNMENT361				ABI_ALIGNMENT
364			}362			}
365		}363		}
366		impl AbiRead<$ty> for AbiReader<'_> {364		impl AbiRead for $ty {
367			fn abi_read(&mut self) -> Result<$ty> {365			fn abi_read(reader: &mut AbiReader) -> Result<$ty> {
368				self.$method()366				reader.$method()
369			}367			}
370		}368		}
371	};369	};
389		ABI_ALIGNMENT387		ABI_ALIGNMENT
390	}388	}
391}389}
392impl AbiRead<bytes> for AbiReader<'_> {390impl AbiRead for bytes {
393	fn abi_read(&mut self) -> Result<bytes> {391	fn abi_read(reader: &mut AbiReader) -> Result<bytes> {
394		Ok(bytes(self.bytes()?))392		Ok(bytes(reader.bytes()?))
395	}393	}
396}394}
397395
405impl sealed::CanBePlacedInVec for H160 {}403impl sealed::CanBePlacedInVec for H160 {}
406impl sealed::CanBePlacedInVec for EthCrossAccount {}404impl sealed::CanBePlacedInVec for EthCrossAccount {}
407405
408impl<R: sealed::CanBePlacedInVec> AbiRead<Vec<R>> for AbiReader<'_>406impl<R: AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {
409where
410	Self: AbiRead<R>,
411{
412	fn abi_read(&mut self) -> Result<Vec<R>> {407	fn abi_read(reader: &mut AbiReader) -> Result<Vec<R>> {
413		let mut sub = self.subresult(None)?;408		let mut sub = reader.subresult(None)?;
414		let size = sub.uint32()? as usize;409		let size = sub.uint32()? as usize;
415		sub.subresult_offset = sub.offset;410		sub.subresult_offset = sub.offset;
416		let mut out = Vec::with_capacity(size);411		let mut out = Vec::with_capacity(size);
417		for _ in 0..size {412		for _ in 0..size {
418			out.push(<Self as AbiRead<R>>::abi_read(&mut sub)?);413			out.push(<R>::abi_read(&mut sub)?);
419		}414		}
420		Ok(out)415		Ok(out)
421	}416	}
435	}430	}
436}431}
437432
438impl AbiRead<EthCrossAccount> for AbiReader<'_> {433impl AbiRead for EthCrossAccount {
439	fn abi_read(&mut self) -> Result<EthCrossAccount> {434	fn abi_read(reader: &mut AbiReader) -> Result<EthCrossAccount> {
440		let size = if !EthCrossAccount::is_dynamic() {435		let size = if !EthCrossAccount::is_dynamic() {
441			Some(<EthCrossAccount as TypeHelper>::size())436			Some(<EthCrossAccount as TypeHelper>::size())
442		} else {437		} else {
443			None438			None
444		};439		};
445		let mut subresult = self.subresult(size)?;440		let mut subresult = reader.subresult(size)?;
446		let eth = <Self as AbiRead<address>>::abi_read(&mut subresult)?;441		let eth = <address>::abi_read(&mut subresult)?;
447		let sub = <Self as AbiRead<uint256>>::abi_read(&mut subresult)?;442		let sub = <uint256>::abi_read(&mut subresult)?;
448443
449		Ok(EthCrossAccount { eth, sub })444		Ok(EthCrossAccount { eth, sub })
450	}445	}
479474
480		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}475		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
481476
482		impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>477		impl<$($ident),+> AbiRead for ($($ident,)+)
483		where478		where
484			$(479			$($ident: AbiRead,)+
485				Self: AbiRead<$ident>,
486			)+
487			($($ident,)+): TypeHelper,480			($($ident,)+): TypeHelper,
488		{481		{
489			fn abi_read(&mut self) -> Result<($($ident,)+)> {482			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {
490				let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };483				let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };
491				let mut subresult = self.subresult(size)?;484				let mut subresult = reader.subresult(size)?;
492				Ok((485				Ok((
493					$(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+486					$(<$ident>::abi_read(&mut subresult)?,)+
494				))487				))
495			}488			}
496		}489		}
683676
684					let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();677					let (call, mut decoder) = AbiReader::new_call(encoded_data).unwrap();
685					assert_eq!(call, u32::to_be_bytes(function_identifier));678					assert_eq!(call, u32::to_be_bytes(function_identifier));
686					let data = <AbiReader<'_> as AbiRead<$type>>::abi_read(&mut decoder).unwrap();679					let data = <$type>::abi_read(&mut decoder).unwrap();
687					assert_eq!(data, decoded_data);680					assert_eq!(data, decoded_data);
688681
689					let mut writer = AbiWriter::new_call(function_identifier);682					let mut writer = AbiWriter::new_call(function_identifier);
890		assert_eq!(call, u32::to_be_bytes(decoded_data.0));883		assert_eq!(call, u32::to_be_bytes(decoded_data.0));
891		let address = decoder.address().unwrap();884		let address = decoder.address().unwrap();
892		let data =885		let data = <Vec<(uint256, string)>>::abi_read(&mut decoder).unwrap();
893			<AbiReader<'_> as AbiRead<Vec<(uint256, string)>>>::abi_read(&mut decoder).unwrap();
894		assert_eq!(data, decoded_data.1);886		assert_eq!(data, decoded_data.1);
895887
896		let mut writer = AbiWriter::new_call(decoded_data.0);888		let mut writer = AbiWriter::new_call(decoded_data.0);

341			return Ok(None);341			return Ok(None);
342		}342		}
343		Ok(Some(Self::SupportsInterface {343		Ok(Some(Self::SupportsInterface {
344			interface_id: input.abi_read()?,344			interface_id: types::bytes4::abi_read(input)?,
345		}))345		}))
346	}346	}
347}347}

3535
36use crate::{36use crate::{
37	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,37	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
38	eth::{convert_cross_account_to_uint256, convert_tuple_to_cross_account},38	eth::convert_cross_account_to_uint256, weights::WeightInfo,
39	weights::WeightInfo,
40};39};
4140