1234#![allow(dead_code)]56#[cfg(not(feature = "std"))]7use alloc::{8 string::{String, ToString},9 vec::Vec,10};11use evm_core::ExitError;12use primitive_types::{H160, U256};1314use crate::{execution::Error, types::string};15use crate::execution::Result;1617const ABI_ALIGNMENT: usize = 32;1819#[derive(Clone)]20pub struct AbiReader<'i> {21 buf: &'i [u8],22 offset: usize,23}24impl<'i> AbiReader<'i> {25 pub fn new(buf: &'i [u8]) -> Self {26 Self { buf, offset: 0 }27 }28 pub fn new_call(buf: &'i [u8]) -> Result<(u32, Self)> {29 if buf.len() < 4 {30 return Err(Error::Error(ExitError::OutOfOffset));31 }32 let mut method_id = [0; 4];33 method_id.copy_from_slice(&buf[0..4]);3435 Ok((u32::from_be_bytes(method_id), Self { buf, offset: 4 }))36 }3738 fn read_padleft<const S: usize>(&mut self) -> Result<[u8; S]> {39 if self.buf.len() - self.offset < 32 {40 return Err(Error::Error(ExitError::OutOfOffset));41 }42 let mut block = [0; S];43 44 if !self.buf[self.offset..self.offset + ABI_ALIGNMENT - S]45 .iter()46 .all(|&v| v == 0)47 {48 return Err(Error::Error(ExitError::InvalidRange));49 }50 block.copy_from_slice(51 &self.buf[self.offset + ABI_ALIGNMENT - S..self.offset + ABI_ALIGNMENT],52 );53 self.offset += ABI_ALIGNMENT;54 Ok(block)55 }5657 pub fn address(&mut self) -> Result<H160> {58 Ok(H160(self.read_padleft()?))59 }6061 pub fn bool(&mut self) -> Result<bool> {62 let data: [u8; 1] = self.read_padleft()?;63 match data[0] {64 0 => Ok(false),65 1 => Ok(true),66 _ => Err(Error::Error(ExitError::InvalidRange)),67 }68 }6970 pub fn bytes4(&mut self) -> Result<[u8; 4]> {71 self.read_padleft()72 }7374 pub fn bytes(&mut self) -> Result<Vec<u8>> {75 let mut subresult = self.subresult()?;76 let length = subresult.read_usize()?;77 if subresult.buf.len() <= subresult.offset + length {78 return Err(Error::Error(ExitError::OutOfOffset));79 }80 Ok(subresult.buf[subresult.offset..subresult.offset + length].into())81 }8283 pub fn uint32(&mut self) -> Result<u32> {84 Ok(u32::from_be_bytes(self.read_padleft()?))85 }8687 pub fn uint128(&mut self) -> Result<u128> {88 Ok(u128::from_be_bytes(self.read_padleft()?))89 }9091 pub fn uint256(&mut self) -> Result<U256> {92 let buf: [u8; 32] = self.read_padleft()?;93 Ok(U256::from_big_endian(&buf))94 }9596 pub fn uint64(&mut self) -> Result<u64> {97 Ok(u64::from_be_bytes(self.read_padleft()?))98 }99100 pub fn read_usize(&mut self) -> Result<usize> {101 Ok(usize::from_be_bytes(self.read_padleft()?))102 }103104 fn subresult(&mut self) -> Result<AbiReader<'i>> {105 let offset = self.read_usize()?;106 Ok(AbiReader {107 buf: self.buf,108 offset: offset + self.offset,109 })110 }111112 pub fn is_finished(&self) -> bool {113 self.buf.len() == self.offset114 }115}116117#[derive(Default)]118pub struct AbiWriter {119 static_part: Vec<u8>,120 dynamic_part: Vec<(usize, AbiWriter)>,121}122impl AbiWriter {123 pub fn new() -> Self {124 Self::default()125 }126 pub fn new_call(method_id: u32) -> Self {127 let mut val = Self::new();128 val.static_part.extend(&method_id.to_be_bytes());129 val130 }131132 fn write_padleft(&mut self, block: &[u8]) {133 assert!(block.len() <= ABI_ALIGNMENT);134 self.static_part135 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);136 self.static_part.extend(block);137 }138139 fn write_padright(&mut self, bytes: &[u8]) {140 assert!(bytes.len() <= ABI_ALIGNMENT);141 self.static_part.extend(bytes);142 self.static_part143 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - bytes.len()]);144 }145146 pub fn address(&mut self, address: &H160) {147 self.write_padleft(&address.0)148 }149150 pub fn bool(&mut self, value: &bool) {151 self.write_padleft(&[if *value { 1 } else { 0 }])152 }153154 pub fn uint8(&mut self, value: &u8) {155 self.write_padleft(&[*value])156 }157158 pub fn uint32(&mut self, value: &u32) {159 self.write_padleft(&u32::to_be_bytes(*value))160 }161162 pub fn uint128(&mut self, value: &u128) {163 self.write_padleft(&u128::to_be_bytes(*value))164 }165166 pub fn uint256(&mut self, value: &U256) {167 let mut out = [0; 32];168 value.to_big_endian(&mut out);169 self.write_padleft(&out)170 }171172 pub fn write_usize(&mut self, value: &usize) {173 self.write_padleft(&usize::to_be_bytes(*value))174 }175176 pub fn write_subresult(&mut self, result: Self) {177 self.dynamic_part.push((self.static_part.len(), result));178 179 self.write_padleft(&[]);180 }181182 pub fn memory(&mut self, value: &[u8]) {183 let mut sub = Self::new();184 sub.write_usize(&value.len());185 for chunk in value.chunks(ABI_ALIGNMENT) {186 sub.write_padright(chunk);187 }188 self.write_subresult(sub);189 }190191 pub fn string(&mut self, value: &str) {192 self.memory(value.as_bytes())193 }194195 pub fn finish(mut self) -> Vec<u8> {196 for (static_offset, part) in self.dynamic_part {197 let part_offset = self.static_part.len();198199 let encoded_dynamic_offset = usize::to_be_bytes(part_offset - static_offset);200 self.static_part[static_offset + ABI_ALIGNMENT - encoded_dynamic_offset.len()201 ..static_offset + ABI_ALIGNMENT]202 .copy_from_slice(&encoded_dynamic_offset);203 self.static_part.extend(part.finish())204 }205 self.static_part206 }207}208209pub trait AbiRead<T> {210 fn abi_read(&mut self) -> Result<T>;211}212213macro_rules! impl_abi_readable {214 ($ty:ty, $method:ident) => {215 impl AbiRead<$ty> for AbiReader<'_> {216 fn abi_read(&mut self) -> Result<$ty> {217 self.$method()218 }219 }220 };221}222223impl_abi_readable!(u32, uint32);224impl_abi_readable!(u128, uint128);225impl_abi_readable!(U256, uint256);226impl_abi_readable!(H160, address);227impl_abi_readable!(Vec<u8>, bytes);228impl_abi_readable!(bool, bool);229230pub trait AbiWrite {231 fn abi_write(&self, writer: &mut AbiWriter);232}233234macro_rules! impl_abi_writeable {235 ($ty:ty, $method:ident) => {236 impl AbiWrite for $ty {237 fn abi_write(&self, writer: &mut AbiWriter) {238 writer.$method(&self)239 }240 }241 };242}243244impl_abi_writeable!(u8, uint8);245impl_abi_writeable!(u32, uint32);246impl_abi_writeable!(u128, uint128);247impl_abi_writeable!(U256, uint256);248impl_abi_writeable!(H160, address);249impl_abi_writeable!(bool, bool);250impl_abi_writeable!(&str, string);251impl AbiWrite for &string {252 fn abi_write(&self, writer: &mut AbiWriter) {253 writer.string(self)254 }255}256257impl AbiWrite for () {258 fn abi_write(&self, _writer: &mut AbiWriter) {}259}260261#[macro_export]262macro_rules! abi_decode {263 ($reader:expr, $($name:ident: $typ:ident),+ $(,)?) => {264 $(265 let $name = $reader.$typ()?;266 )+267 }268}269#[macro_export]270macro_rules! abi_encode {271 ($($typ:ident($value:expr)),* $(,)?) => {{272 #[allow(unused_mut)]273 let mut writer = ::evm_coder::abi::AbiWriter::new();274 $(275 writer.$typ($value);276 )*277 writer278 }};279 (call $val:expr; $($typ:ident($value:expr)),* $(,)?) => {{280 #[allow(unused_mut)]281 let mut writer = ::evm_coder::abi::AbiWriter::new_call($val);282 $(283 writer.$typ($value);284 )*285 writer286 }}287}