difftreelog
fix(evm-coder) subresult parsing
in: master
Subresult offset should be based on current subresult start, not on current item offset
1 file changed
crates/evm-coder/src/abi.rsdiffbeforeafterboth1//! TODO: I misunterstood therminology, abi IS rlp encoded, so2//! this module should be replaced with rlp crate34#![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 // Verify padding is empty44 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 }82 pub fn string(&mut self) -> Result<string> {83 string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))84 }8586 pub fn uint32(&mut self) -> Result<u32> {87 Ok(u32::from_be_bytes(self.read_padleft()?))88 }8990 pub fn uint128(&mut self) -> Result<u128> {91 Ok(u128::from_be_bytes(self.read_padleft()?))92 }9394 pub fn uint256(&mut self) -> Result<U256> {95 let buf: [u8; 32] = self.read_padleft()?;96 Ok(U256::from_big_endian(&buf))97 }9899 pub fn uint64(&mut self) -> Result<u64> {100 Ok(u64::from_be_bytes(self.read_padleft()?))101 }102103 pub fn read_usize(&mut self) -> Result<usize> {104 Ok(usize::from_be_bytes(self.read_padleft()?))105 }106107 fn subresult(&mut self) -> Result<AbiReader<'i>> {108 let offset = self.read_usize()?;109 Ok(AbiReader {110 buf: self.buf,111 offset: offset + self.offset,112 })113 }114115 pub fn is_finished(&self) -> bool {116 self.buf.len() == self.offset117 }118}119120#[derive(Default)]121pub struct AbiWriter {122 static_part: Vec<u8>,123 dynamic_part: Vec<(usize, AbiWriter)>,124}125impl AbiWriter {126 pub fn new() -> Self {127 Self::default()128 }129 pub fn new_call(method_id: u32) -> Self {130 let mut val = Self::new();131 val.static_part.extend(&method_id.to_be_bytes());132 val133 }134135 fn write_padleft(&mut self, block: &[u8]) {136 assert!(block.len() <= ABI_ALIGNMENT);137 self.static_part138 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);139 self.static_part.extend(block);140 }141142 fn write_padright(&mut self, bytes: &[u8]) {143 assert!(bytes.len() <= ABI_ALIGNMENT);144 self.static_part.extend(bytes);145 self.static_part146 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - bytes.len()]);147 }148149 pub fn address(&mut self, address: &H160) {150 self.write_padleft(&address.0)151 }152153 pub fn bool(&mut self, value: &bool) {154 self.write_padleft(&[if *value { 1 } else { 0 }])155 }156157 pub fn uint8(&mut self, value: &u8) {158 self.write_padleft(&[*value])159 }160161 pub fn uint32(&mut self, value: &u32) {162 self.write_padleft(&u32::to_be_bytes(*value))163 }164165 pub fn uint128(&mut self, value: &u128) {166 self.write_padleft(&u128::to_be_bytes(*value))167 }168169 pub fn uint256(&mut self, value: &U256) {170 let mut out = [0; 32];171 value.to_big_endian(&mut out);172 self.write_padleft(&out)173 }174175 pub fn write_usize(&mut self, value: &usize) {176 self.write_padleft(&usize::to_be_bytes(*value))177 }178179 pub fn write_subresult(&mut self, result: Self) {180 self.dynamic_part.push((self.static_part.len(), result));181 // Empty block, to be filled later182 self.write_padleft(&[]);183 }184185 pub fn memory(&mut self, value: &[u8]) {186 let mut sub = Self::new();187 sub.write_usize(&value.len());188 for chunk in value.chunks(ABI_ALIGNMENT) {189 sub.write_padright(chunk);190 }191 self.write_subresult(sub);192 }193194 pub fn string(&mut self, value: &str) {195 self.memory(value.as_bytes())196 }197198 pub fn finish(mut self) -> Vec<u8> {199 for (static_offset, part) in self.dynamic_part {200 let part_offset = self.static_part.len();201202 let encoded_dynamic_offset = usize::to_be_bytes(part_offset - static_offset);203 self.static_part[static_offset + ABI_ALIGNMENT - encoded_dynamic_offset.len()204 ..static_offset + ABI_ALIGNMENT]205 .copy_from_slice(&encoded_dynamic_offset);206 self.static_part.extend(part.finish())207 }208 self.static_part209 }210}211212pub trait AbiRead<T> {213 fn abi_read(&mut self) -> Result<T>;214}215216macro_rules! impl_abi_readable {217 ($ty:ty, $method:ident) => {218 impl AbiRead<$ty> for AbiReader<'_> {219 fn abi_read(&mut self) -> Result<$ty> {220 self.$method()221 }222 }223 };224}225226impl_abi_readable!(u32, uint32);227impl_abi_readable!(u128, uint128);228impl_abi_readable!(U256, uint256);229impl_abi_readable!(H160, address);230impl_abi_readable!(Vec<u8>, bytes);231impl_abi_readable!(bool, bool);232impl_abi_readable!(string, string);233234pub trait AbiWrite {235 fn abi_write(&self, writer: &mut AbiWriter);236}237238macro_rules! impl_abi_writeable {239 ($ty:ty, $method:ident) => {240 impl AbiWrite for $ty {241 fn abi_write(&self, writer: &mut AbiWriter) {242 writer.$method(&self)243 }244 }245 };246}247248impl_abi_writeable!(u8, uint8);249impl_abi_writeable!(u32, uint32);250impl_abi_writeable!(u128, uint128);251impl_abi_writeable!(U256, uint256);252impl_abi_writeable!(H160, address);253impl_abi_writeable!(bool, bool);254impl_abi_writeable!(&str, string);255impl AbiWrite for &string {256 fn abi_write(&self, writer: &mut AbiWriter) {257 writer.string(self)258 }259}260261impl AbiWrite for () {262 fn abi_write(&self, _writer: &mut AbiWriter) {}263}264265#[macro_export]266macro_rules! abi_decode {267 ($reader:expr, $($name:ident: $typ:ident),+ $(,)?) => {268 $(269 let $name = $reader.$typ()?;270 )+271 }272}273#[macro_export]274macro_rules! abi_encode {275 ($($typ:ident($value:expr)),* $(,)?) => {{276 #[allow(unused_mut)]277 let mut writer = ::evm_coder::abi::AbiWriter::new();278 $(279 writer.$typ($value);280 )*281 writer282 }};283 (call $val:expr; $($typ:ident($value:expr)),* $(,)?) => {{284 #[allow(unused_mut)]285 let mut writer = ::evm_coder::abi::AbiWriter::new_call($val);286 $(287 writer.$typ($value);288 )*289 writer290 }}291}1//! TODO: I misunterstood therminology, abi IS rlp encoded, so2//! this module should be replaced with rlp crate34#![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 subresult_offset: usize,23 offset: usize,24}25impl<'i> AbiReader<'i> {26 pub fn new(buf: &'i [u8]) -> Self {27 Self {28 buf,29 subresult_offset: 0,30 offset: 0,31 }32 }33 pub fn new_call(buf: &'i [u8]) -> Result<(u32, Self)> {34 if buf.len() < 4 {35 return Err(Error::Error(ExitError::OutOfOffset));36 }37 let mut method_id = [0; 4];38 method_id.copy_from_slice(&buf[0..4]);3940 Ok((41 u32::from_be_bytes(method_id),42 Self {43 buf,44 subresult_offset: 4,45 offset: 4,46 },47 ))48 }4950 fn read_padleft<const S: usize>(&mut self) -> Result<[u8; S]> {51 if self.buf.len() - self.offset < ABI_ALIGNMENT {52 return Err(Error::Error(ExitError::OutOfOffset));53 }54 let mut block = [0; S];55 // Verify padding is empty56 if !self.buf[self.offset..self.offset + ABI_ALIGNMENT - S]57 .iter()58 .all(|&v| v == 0)59 {60 return Err(Error::Error(ExitError::InvalidRange));61 }62 block.copy_from_slice(63 &self.buf[self.offset + ABI_ALIGNMENT - S..self.offset + ABI_ALIGNMENT],64 );65 self.offset += ABI_ALIGNMENT;66 Ok(block)67 }6869 pub fn address(&mut self) -> Result<H160> {70 Ok(H160(self.read_padleft()?))71 }7273 pub fn bool(&mut self) -> Result<bool> {74 let data: [u8; 1] = self.read_padleft()?;75 match data[0] {76 0 => Ok(false),77 1 => Ok(true),78 _ => Err(Error::Error(ExitError::InvalidRange)),79 }80 }8182 pub fn bytes4(&mut self) -> Result<[u8; 4]> {83 self.read_padleft()84 }8586 pub fn bytes(&mut self) -> Result<Vec<u8>> {87 let mut subresult = self.subresult()?;88 let length = subresult.read_usize()?;89 if subresult.buf.len() <= subresult.offset + length {90 return Err(Error::Error(ExitError::OutOfOffset));91 }92 Ok(subresult.buf[subresult.offset..subresult.offset + length].into())93 }94 pub fn string(&mut self) -> Result<string> {95 string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))96 }9798 pub fn uint32(&mut self) -> Result<u32> {99 Ok(u32::from_be_bytes(self.read_padleft()?))100 }101102 pub fn uint128(&mut self) -> Result<u128> {103 Ok(u128::from_be_bytes(self.read_padleft()?))104 }105106 pub fn uint256(&mut self) -> Result<U256> {107 let buf: [u8; 32] = self.read_padleft()?;108 Ok(U256::from_big_endian(&buf))109 }110111 pub fn uint64(&mut self) -> Result<u64> {112 Ok(u64::from_be_bytes(self.read_padleft()?))113 }114115 pub fn read_usize(&mut self) -> Result<usize> {116 Ok(usize::from_be_bytes(self.read_padleft()?))117 }118119 fn subresult(&mut self) -> Result<AbiReader<'i>> {120 let offset = self.read_usize()?;121 if offset + self.subresult_offset > self.buf.len() {122 return Err(Error::Error(ExitError::InvalidRange));123 }124 Ok(AbiReader {125 buf: self.buf,126 subresult_offset: offset + self.subresult_offset,127 offset: offset + self.subresult_offset,128 })129 }130131 pub fn is_finished(&self) -> bool {132 self.buf.len() == self.offset133 }134}135136#[derive(Default)]137pub struct AbiWriter {138 static_part: Vec<u8>,139 dynamic_part: Vec<(usize, AbiWriter)>,140}141impl AbiWriter {142 pub fn new() -> Self {143 Self::default()144 }145 pub fn new_call(method_id: u32) -> Self {146 let mut val = Self::new();147 val.static_part.extend(&method_id.to_be_bytes());148 val149 }150151 fn write_padleft(&mut self, block: &[u8]) {152 assert!(block.len() <= ABI_ALIGNMENT);153 self.static_part154 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);155 self.static_part.extend(block);156 }157158 fn write_padright(&mut self, bytes: &[u8]) {159 assert!(bytes.len() <= ABI_ALIGNMENT);160 self.static_part.extend(bytes);161 self.static_part162 .extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - bytes.len()]);163 }164165 pub fn address(&mut self, address: &H160) {166 self.write_padleft(&address.0)167 }168169 pub fn bool(&mut self, value: &bool) {170 self.write_padleft(&[if *value { 1 } else { 0 }])171 }172173 pub fn uint8(&mut self, value: &u8) {174 self.write_padleft(&[*value])175 }176177 pub fn uint32(&mut self, value: &u32) {178 self.write_padleft(&u32::to_be_bytes(*value))179 }180181 pub fn uint128(&mut self, value: &u128) {182 self.write_padleft(&u128::to_be_bytes(*value))183 }184185 pub fn uint256(&mut self, value: &U256) {186 let mut out = [0; 32];187 value.to_big_endian(&mut out);188 self.write_padleft(&out)189 }190191 pub fn write_usize(&mut self, value: &usize) {192 self.write_padleft(&usize::to_be_bytes(*value))193 }194195 pub fn write_subresult(&mut self, result: Self) {196 self.dynamic_part.push((self.static_part.len(), result));197 // Empty block, to be filled later198 self.write_padleft(&[]);199 }200201 pub fn memory(&mut self, value: &[u8]) {202 let mut sub = Self::new();203 sub.write_usize(&value.len());204 for chunk in value.chunks(ABI_ALIGNMENT) {205 sub.write_padright(chunk);206 }207 self.write_subresult(sub);208 }209210 pub fn string(&mut self, value: &str) {211 self.memory(value.as_bytes())212 }213214 pub fn finish(mut self) -> Vec<u8> {215 for (static_offset, part) in self.dynamic_part {216 let part_offset = self.static_part.len();217218 let encoded_dynamic_offset = usize::to_be_bytes(part_offset);219 self.static_part[static_offset + ABI_ALIGNMENT - encoded_dynamic_offset.len()220 ..static_offset + ABI_ALIGNMENT]221 .copy_from_slice(&encoded_dynamic_offset);222 self.static_part.extend(part.finish())223 }224 self.static_part225 }226}227228pub trait AbiRead<T> {229 fn abi_read(&mut self) -> Result<T>;230}231232macro_rules! impl_abi_readable {233 ($ty:ty, $method:ident) => {234 impl AbiRead<$ty> for AbiReader<'_> {235 fn abi_read(&mut self) -> Result<$ty> {236 self.$method()237 }238 }239 };240}241242impl_abi_readable!(u32, uint32);243impl_abi_readable!(u128, uint128);244impl_abi_readable!(U256, uint256);245impl_abi_readable!(H160, address);246impl_abi_readable!(Vec<u8>, bytes);247impl_abi_readable!(bool, bool);248impl_abi_readable!(string, string);249250pub trait AbiWrite {251 fn abi_write(&self, writer: &mut AbiWriter);252}253254macro_rules! impl_abi_writeable {255 ($ty:ty, $method:ident) => {256 impl AbiWrite for $ty {257 fn abi_write(&self, writer: &mut AbiWriter) {258 writer.$method(&self)259 }260 }261 };262}263264impl_abi_writeable!(u8, uint8);265impl_abi_writeable!(u32, uint32);266impl_abi_writeable!(u128, uint128);267impl_abi_writeable!(U256, uint256);268impl_abi_writeable!(H160, address);269impl_abi_writeable!(bool, bool);270impl_abi_writeable!(&str, string);271impl AbiWrite for &string {272 fn abi_write(&self, writer: &mut AbiWriter) {273 writer.string(self)274 }275}276277impl AbiWrite for () {278 fn abi_write(&self, _writer: &mut AbiWriter) {}279}280281#[macro_export]282macro_rules! abi_decode {283 ($reader:expr, $($name:ident: $typ:ident),+ $(,)?) => {284 $(285 let $name = $reader.$typ()?;286 )+287 }288}289#[macro_export]290macro_rules! abi_encode {291 ($($typ:ident($value:expr)),* $(,)?) => {{292 #[allow(unused_mut)]293 let mut writer = ::evm_coder::abi::AbiWriter::new();294 $(295 writer.$typ($value);296 )*297 writer298 }};299 (call $val:expr; $($typ:ident($value:expr)),* $(,)?) => {{300 #[allow(unused_mut)]301 let mut writer = ::evm_coder::abi::AbiWriter::new_call($val);302 $(303 writer.$typ($value);304 )*305 writer306 }}307}308309#[cfg(test)]310pub mod test {311 use super::{AbiReader, AbiWriter};312 use hex_literal::hex;313314 #[test]315 fn dynamic_after_static() {316 let mut encoder = AbiWriter::new();317 encoder.bool(&true);318 encoder.string("test");319 let encoded = encoder.finish();320321 let mut encoder = AbiWriter::new();322 encoder.bool(&true);323 // Offset to subresult324 encoder.uint32(&(32 * 2));325 // Len of "test"326 encoder.uint32(&4);327 encoder.write_padright(&[b't', b'e', b's', b't']);328 let alternative_encoded = encoder.finish();329330 assert_eq!(encoded, alternative_encoded);331332 let mut decoder = AbiReader::new(&encoded);333 assert_eq!(decoder.bool().unwrap(), true);334 assert_eq!(decoder.string().unwrap(), "test");335 }336337 #[test]338 fn mint_sample() {339 let (call, mut decoder) = AbiReader::new_call(&hex!(340 "341 50bb4e7f342 000000000000000000000000ad2c0954693c2b5404b7e50967d3481bea432374343 0000000000000000000000000000000000000000000000000000000000000001344 0000000000000000000000000000000000000000000000000000000000000060345 0000000000000000000000000000000000000000000000000000000000000008346 5465737420555249000000000000000000000000000000000000000000000000347 "348 ))349 .unwrap();350 assert_eq!(call, 0x50bb4e7f);351 assert_eq!(352 format!("{:?}", decoder.address().unwrap()),353 "0xad2c0954693c2b5404b7e50967d3481bea432374"354 );355 assert_eq!(decoder.uint32().unwrap(), 1);356 assert_eq!(decoder.string().unwrap(), "Test URI");357 }358}