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 231 (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}243244245246247248impl<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,)+314 {315 fn abi_write(&self, writer: &mut AbiWriter) {316 let ($($ident,)+) = self;317 if writer.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}