git.delta.rocks / unique-network / refs/commits / 08c4c52a9f35

1use crate::{2	custom_signature::SignatureUnit,3	execution::{Result, ResultWithPostInfo, WithPostDispatchInfo},4	make_signature, sealed,5	types::*,6};7use super::{traits::*, ABI_ALIGNMENT, AbiReader, AbiWriter};8use primitive_types::{U256, H160};910#[cfg(not(feature = "std"))]11use alloc::vec::Vec;1213macro_rules! impl_abi_type {14	($ty:ty, $name:ident, $dynamic:literal) => {15		impl sealed::CanBePlacedInVec for $ty {}1617		impl AbiType for $ty {18			const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($name)));1920			fn is_dynamic() -> bool {21				$dynamic22			}2324			fn size() -> usize {25				ABI_ALIGNMENT26			}27		}28	};29}3031macro_rules! impl_abi_readable {32	($ty:ty, $method:ident) => {33		impl AbiRead for $ty {34			fn abi_read(reader: &mut AbiReader) -> Result<$ty> {35				reader.$method()36			}37		}38	};39}4041macro_rules! impl_abi_writeable {42	($ty:ty, $method:ident) => {43		impl AbiWrite for $ty {44			fn abi_write(&self, writer: &mut AbiWriter) {45				writer.$method(&self)46			}47		}48	};49}5051macro_rules! impl_abi {52	($ty:ty, $method:ident, $dynamic:literal) => {53		impl_abi_type!($ty, $method, $dynamic);54		impl_abi_readable!($ty, $method);55		impl_abi_writeable!($ty, $method);56	};57}5859impl_abi!(bool, bool, false);60impl_abi!(u8, uint8, false);61impl_abi!(u32, uint32, false);62impl_abi!(u64, uint64, false);63impl_abi!(u128, uint128, false);64impl_abi!(U256, uint256, false);65impl_abi!(H160, address, false);66impl_abi!(string, string, true);6768impl_abi_writeable!(&str, string);6970impl_abi_type!(bytes, bytes, true);7172impl AbiRead for bytes {73	fn abi_read(reader: &mut AbiReader) -> Result<bytes> {74		Ok(bytes(reader.bytes()?))75	}76}7778impl AbiWrite for bytes {79	fn abi_write(&self, writer: &mut AbiWriter) {80		writer.bytes(self.0.as_slice())81	}82}8384impl_abi_type!(bytes4, bytes4, false);85impl AbiRead for bytes4 {86	fn abi_read(reader: &mut AbiReader) -> Result<bytes4> {87		reader.bytes4()88	}89}9091impl<T: AbiWrite> AbiWrite for &T {92	fn abi_write(&self, writer: &mut AbiWriter) {93		T::abi_write(self, writer);94	}95}9697impl<T: AbiType> AbiType for &T {98	const SIGNATURE: SignatureUnit = T::SIGNATURE;99100	fn is_dynamic() -> bool {101		T::is_dynamic()102	}103104	fn size() -> usize {105		T::size()106	}107}108109impl<T: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<T> {110	fn abi_read(reader: &mut AbiReader) -> Result<Vec<T>> {111		let mut sub = reader.subresult(None)?;112		let size = sub.uint32()? as usize;113		sub.subresult_offset = sub.offset;114		let is_dynamic = <T as AbiType>::is_dynamic();115		let mut out = Vec::with_capacity(size);116		for _ in 0..size {117			out.push(<T as AbiRead>::abi_read(&mut sub)?);118			if !is_dynamic {119				sub.bytes_read(<T as AbiType>::size());120			};121		}122		Ok(out)123	}124}125126impl<T: AbiType> AbiType for Vec<T> {127	const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));128129	fn is_dynamic() -> bool {130		true131	}132133	fn size() -> usize {134		ABI_ALIGNMENT135	}136}137138impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {139	fn abi_write(&self, writer: &mut AbiWriter) {140		let is_dynamic = T::is_dynamic();141		let mut sub = if is_dynamic {142			AbiWriter::new_dynamic(is_dynamic)143		} else {144			AbiWriter::new()145		};146147		// Write items count148		(self.len() as u32).abi_write(&mut sub);149150		for item in self {151			item.abi_write(&mut sub);152		}153		writer.write_subresult(sub);154	}155}156157impl AbiWrite for () {158	fn abi_write(&self, _writer: &mut AbiWriter) {}159}160161/// This particular AbiWrite implementation should be split to another trait,162/// which only implements `to_result`, but due to lack of specialization feature163/// in stable Rust, we can't have blanket impl of this trait `for T where T: AbiWrite`,164/// so here we abusing default trait methods for it165impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {166	fn abi_write(&self, _writer: &mut AbiWriter) {167		debug_assert!(false, "shouldn't be called, see comment")168	}169	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {170		match self {171			Ok(v) => Ok(WithPostDispatchInfo {172				post_info: v.post_info.clone(),173				data: {174					let mut out = AbiWriter::new();175					v.data.abi_write(&mut out);176					out177				},178			}),179			Err(e) => Err(e.clone()),180		}181	}182}183184macro_rules! impl_tuples {185	($($ident:ident)+) => {186		impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)187		where188        $(189            $ident: AbiType,190        )+191		{192            const SIGNATURE: SignatureUnit = make_signature!(193                new fixed("(")194                $(nameof(<$ident>::SIGNATURE) fixed(","))+195                shift_left(1)196                fixed(")")197            );198199			fn is_dynamic() -> bool {200				false201				$(202					|| <$ident>::is_dynamic()203				)*204			}205206			fn size() -> usize {207				0 $(+ <$ident>::size())+208			}209		}210211		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}212213		impl<$($ident),+> AbiRead for ($($ident,)+)214		where215			Self: AbiType,216			$($ident: AbiRead + AbiType,)+217		{218			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {219				let is_dynamic = <Self>::is_dynamic();220				let size = if !is_dynamic { Some(<Self>::size()) } else { None };221				let mut subresult = reader.subresult(size)?;222				Ok((223					$({224						let value = <$ident>::abi_read(&mut subresult)?;225						if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};226						value227					},)+228				))229			}230		}231232		#[allow(non_snake_case)]233		impl<$($ident),+> AbiWrite for ($($ident,)+)234		where235			$($ident: AbiWrite + AbiType,)+236		{237			fn abi_write(&self, writer: &mut AbiWriter) {238				let ($($ident,)+) = self;239				if <Self as AbiType>::is_dynamic() {240					let mut sub = AbiWriter::new();241					$($ident.abi_write(&mut sub);)+242					writer.write_subresult(sub);243				} else {244					$($ident.abi_write(writer);)+245				}246			}247		}248	};249}250251impl_tuples! {A}252impl_tuples! {A B}253impl_tuples! {A B C}254impl_tuples! {A B C D}255impl_tuples! {A B C D E}256impl_tuples! {A B C D E F}257impl_tuples! {A B C D E F G}258impl_tuples! {A B C D E F G H}259impl_tuples! {A B C D E F G H I}260impl_tuples! {A B C D E F G H I J}261262//----- impls for Option -----263impl<T: AbiType> AbiType for Option<T> {264	const SIGNATURE: SignatureUnit = <(bool, T)>::SIGNATURE;265266	fn is_dynamic() -> bool {267		<(bool, T)>::is_dynamic()268	}269270	fn size() -> usize {271		<(bool, T)>::size()272	}273}274275impl<T: AbiWrite + AbiType + Default> AbiWrite for Option<T> {276	fn abi_write(&self, writer: &mut AbiWriter) {277		match self {278			Some(value) => (true, value).abi_write(writer),279			None => (false, T::default()).abi_write(writer),280		}281	}282}283284impl<T> AbiRead for Option<T>285where286	Self: AbiType,287	T: AbiRead + AbiType,288{289	fn abi_read(reader: &mut AbiReader) -> Result<Self>290	where291		Self: Sized,292	{293		let (status, value) = <(bool, T)>::abi_read(reader)?;294		Ok(if status { Some(value) } else { None })295	}296}