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

1use crate::{2	execution::{Result, ResultWithPostInfo, WithPostDispatchInfo},3	types::*,4	make_signature,5	custom_signature::SignatureUnit,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_readable {14	($ty:ty, $method:ident, $dynamic:literal) => {15		impl sealed::CanBePlacedInVec for $ty {}1617		impl AbiType for $ty {18			const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($ty)));1920			fn is_dynamic() -> bool {21				$dynamic22			}2324			fn size() -> usize {25				ABI_ALIGNMENT26			}27		}2829		impl AbiRead for $ty {30			fn abi_read(reader: &mut AbiReader) -> Result<$ty> {31				reader.$method()32			}33		}34	};35}3637impl_abi_readable!(uint32, uint32, false);38impl_abi_readable!(uint64, uint64, false);39impl_abi_readable!(uint128, uint128, false);40impl_abi_readable!(uint256, uint256, false);41impl_abi_readable!(bytes4, bytes4, false);42impl_abi_readable!(address, address, false);43impl_abi_readable!(string, string, true);4445impl sealed::CanBePlacedInVec for bool {}4647impl AbiType for bool {48	const SIGNATURE: SignatureUnit = make_signature!(new fixed("bool"));4950	fn is_dynamic() -> bool {51		false52	}53	fn size() -> usize {54		ABI_ALIGNMENT55	}56}57impl AbiRead for bool {58	fn abi_read(reader: &mut AbiReader) -> Result<bool> {59		reader.bool()60	}61}6263impl AbiType for uint8 {64	const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));6566	fn is_dynamic() -> bool {67		false68	}69	fn size() -> usize {70		ABI_ALIGNMENT71	}72}73impl AbiRead for uint8 {74	fn abi_read(reader: &mut AbiReader) -> Result<uint8> {75		reader.uint8()76	}77}7879impl AbiType for bytes {80	const SIGNATURE: SignatureUnit = make_signature!(new fixed("bytes"));8182	fn is_dynamic() -> bool {83		true84	}85	fn size() -> usize {86		ABI_ALIGNMENT87	}88}89impl AbiRead for bytes {90	fn abi_read(reader: &mut AbiReader) -> Result<bytes> {91		Ok(bytes(reader.bytes()?))92	}93}9495impl<R: AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<R> {96	fn abi_read(reader: &mut AbiReader) -> Result<Vec<R>> {97		let mut sub = reader.subresult(None)?;98		let size = sub.uint32()? as usize;99		sub.subresult_offset = sub.offset;100		let mut out = Vec::with_capacity(size);101		for _ in 0..size {102			out.push(<R>::abi_read(&mut sub)?);103		}104		Ok(out)105	}106}107108impl<R: AbiType> AbiType for Vec<R> {109	const SIGNATURE: SignatureUnit = make_signature!(new nameof(R::SIGNATURE) fixed("[]"));110111	fn is_dynamic() -> bool {112		true113	}114115	fn size() -> usize {116		ABI_ALIGNMENT117	}118}119120impl sealed::CanBePlacedInVec for EthCrossAccount {}121122impl AbiType for EthCrossAccount {123	const SIGNATURE: SignatureUnit = make_signature!(new fixed("(address,uint256)"));124125	fn is_dynamic() -> bool {126		address::is_dynamic() || uint256::is_dynamic()127	}128129	fn size() -> usize {130		<address as AbiType>::size() + <uint256 as AbiType>::size()131	}132}133134impl AbiRead for EthCrossAccount {135	fn abi_read(reader: &mut AbiReader) -> Result<EthCrossAccount> {136		let size = if !EthCrossAccount::is_dynamic() {137			Some(<EthCrossAccount as AbiType>::size())138		} else {139			None140		};141		let mut subresult = reader.subresult(size)?;142		let eth = <address>::abi_read(&mut subresult)?;143		let sub = <uint256>::abi_read(&mut subresult)?;144145		Ok(EthCrossAccount { eth, sub })146	}147}148149impl AbiWrite for EthCrossAccount {150	fn abi_write(&self, writer: &mut AbiWriter) {151		self.eth.abi_write(writer);152		self.sub.abi_write(writer);153	}154}155156impl sealed::CanBePlacedInVec for Property {}157158impl AbiType for Property {159	const SIGNATURE: SignatureUnit = make_signature!(new fixed("(string,bytes)"));160161	fn is_dynamic() -> bool {162		string::is_dynamic() || bytes::is_dynamic()163	}164165	fn size() -> usize {166		<string as AbiType>::size() + <bytes as AbiType>::size()167	}168}169170impl AbiRead for Property {171	fn abi_read(reader: &mut AbiReader) -> Result<Property> {172		let size = if !Property::is_dynamic() {173			Some(<Property as AbiType>::size())174		} else {175			None176		};177		let mut subresult = reader.subresult(size)?;178		let key = <string>::abi_read(&mut subresult)?;179		let value = <bytes>::abi_read(&mut subresult)?;180181		Ok(Property { key, value })182	}183}184185impl AbiWrite for Property {186	fn abi_write(&self, writer: &mut AbiWriter) {187		(&self.key, &self.value).abi_write(writer);188	}189}190191macro_rules! impl_abi_writeable {192	($ty:ty, $method:ident) => {193		impl AbiWrite for $ty {194			fn abi_write(&self, writer: &mut AbiWriter) {195				writer.$method(&self)196			}197		}198	};199}200201impl_abi_writeable!(u8, uint8);202impl_abi_writeable!(u32, uint32);203impl_abi_writeable!(u128, uint128);204impl_abi_writeable!(U256, uint256);205impl_abi_writeable!(H160, address);206impl_abi_writeable!(bool, bool);207impl_abi_writeable!(&str, string);208209impl AbiWrite for string {210	fn abi_write(&self, writer: &mut AbiWriter) {211		writer.string(self)212	}213}214215impl AbiWrite for bytes {216	fn abi_write(&self, writer: &mut AbiWriter) {217		writer.bytes(self.0.as_slice())218	}219}220221impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {222	fn abi_write(&self, writer: &mut AbiWriter) {223		let is_dynamic = T::is_dynamic();224		let mut sub = if is_dynamic {225			AbiWriter::new_dynamic(is_dynamic)226		} else {227			AbiWriter::new()228		};229230		// Write items count231		(self.len() as u32).abi_write(&mut sub);232233		for item in self {234			item.abi_write(&mut sub);235		}236		writer.write_subresult(sub);237	}238}239240impl AbiWrite for () {241	fn abi_write(&self, _writer: &mut AbiWriter) {}242}243244/// This particular AbiWrite implementation should be split to another trait,245/// which only implements `to_result`, but due to lack of specialization feature246/// in stable Rust, we can't have blanket impl of this trait `for T where T: AbiWrite`,247/// so here we abusing default trait methods for it248impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {249	fn abi_write(&self, _writer: &mut AbiWriter) {250		debug_assert!(false, "shouldn't be called, see comment")251	}252	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {253		match self {254			Ok(v) => Ok(WithPostDispatchInfo {255				post_info: v.post_info.clone(),256				data: {257					let mut out = AbiWriter::new();258					v.data.abi_write(&mut out);259					out260				},261			}),262			Err(e) => Err(e.clone()),263		}264	}265}266267macro_rules! impl_tuples {268	($($ident:ident)+) => {269		impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)270		where271        $(272            $ident: AbiType,273        )+274		{275            const SIGNATURE: SignatureUnit = make_signature!(276                new fixed("(")277                $(nameof(<$ident>::SIGNATURE) fixed(","))+278                shift_left(1)279                fixed(")")280            );281282			fn is_dynamic() -> bool {283				false284				$(285					|| <$ident>::is_dynamic()286				)*287			}288289			fn size() -> usize {290				0 $(+ <$ident>::size())+291			}292		}293294		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}295296		impl<$($ident),+> AbiRead for ($($ident,)+)297		where298			$($ident: AbiRead,)+299			($($ident,)+): AbiType,300		{301			fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {302				let size = if !<($($ident,)+)>::is_dynamic() { Some(<($($ident,)+)>::size()) } else { None };303				let mut subresult = reader.subresult(size)?;304				Ok((305					$(<$ident>::abi_read(&mut subresult)?,)+306				))307			}308		}309310		#[allow(non_snake_case)]311		impl<$($ident),+> AbiWrite for ($($ident,)+)312		where313			$($ident: AbiWrite + AbiType,)+314		{315			fn abi_write(&self, writer: &mut AbiWriter) {316				let ($($ident,)+) = self;317				if <Self as AbiType>::is_dynamic() {318					let mut sub = AbiWriter::new();319					$($ident.abi_write(&mut sub);)+320					writer.write_subresult(sub);321				} else {322					$($ident.abi_write(writer);)+323				}324			}325		}326	};327}328329impl_tuples! {A}330impl_tuples! {A B}331impl_tuples! {A B C}332impl_tuples! {A B C D}333impl_tuples! {A B C D E}334impl_tuples! {A B C D E F}335impl_tuples! {A B C D E F G}336impl_tuples! {A B C D E F G H}337impl_tuples! {A B C D E F G H I}338impl_tuples! {A B C D E F G H I J}