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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! Implementation of EVM RLP reader/writer1819#![allow(dead_code)]2021mod traits;22pub use traits::*;23mod impls;2425#[cfg(test)]26mod test;2728#[cfg(not(feature = "std"))]29use alloc::vec::Vec;30use evm_core::ExitError;31use primitive_types::{H160, U256};3233use crate::{34	execution::{Result, Error},35	types::*,36};3738const ABI_ALIGNMENT: usize = 32;3940/// View into RLP data, which provides method to read typed items from it41#[derive(Clone)]42pub struct AbiReader<'i> {43	buf: &'i [u8],44	subresult_offset: usize,45	offset: usize,46}47impl<'i> AbiReader<'i> {48	/// Start reading RLP buffer, assuming there is no padding bytes49	pub fn new(buf: &'i [u8]) -> Self {50		Self {51			buf,52			subresult_offset: 0,53			offset: 0,54		}55	}56	/// Start reading RLP buffer, parsing first 4 bytes as selector57	pub fn new_call(buf: &'i [u8]) -> Result<(bytes4, Self)> {58		if buf.len() < 4 {59			return Err(Error::Error(ExitError::OutOfOffset));60		}61		let mut method_id = [0; 4];62		method_id.copy_from_slice(&buf[0..4]);6364		Ok((65			method_id,66			Self {67				buf,68				subresult_offset: 4,69				offset: 4,70			},71		))72	}7374	fn read_pad<const S: usize>(75		buf: &[u8],76		offset: usize,77		pad_start: usize,78		pad_end: usize,79		block_start: usize,80		block_end: usize,81	) -> Result<[u8; S]> {82		if buf.len() - offset < ABI_ALIGNMENT {83			return Err(Error::Error(ExitError::OutOfOffset));84		}85		let mut block = [0; S];86		let is_pad_zeroed = buf[pad_start..pad_end].iter().all(|&v| v == 0);87		if !is_pad_zeroed {88			return Err(Error::Error(ExitError::InvalidRange));89		}90		block.copy_from_slice(&buf[block_start..block_end]);91		Ok(block)92	}9394	fn read_padleft<const S: usize>(&mut self) -> Result<[u8; S]> {95		let offset = self.offset;96		self.offset += ABI_ALIGNMENT;97		Self::read_pad(98			self.buf,99			offset,100			offset,101			offset + ABI_ALIGNMENT - S,102			offset + ABI_ALIGNMENT - S,103			offset + ABI_ALIGNMENT,104		)105	}106107	fn read_padright<const S: usize>(&mut self) -> Result<[u8; S]> {108		let offset = self.offset;109		self.offset += ABI_ALIGNMENT;110		Self::read_pad(111			self.buf,112			offset,113			offset + S,114			offset + ABI_ALIGNMENT,115			offset,116			offset + S,117		)118	}119120	/// Read [`H160`] at current position, then advance121	pub fn address(&mut self) -> Result<H160> {122		Ok(H160(self.read_padleft()?))123	}124125	/// Read [`bool`] at current position, then advance126	pub fn bool(&mut self) -> Result<bool> {127		let data: [u8; 1] = self.read_padleft()?;128		match data[0] {129			0 => Ok(false),130			1 => Ok(true),131			_ => Err(Error::Error(ExitError::InvalidRange)),132		}133	}134135	/// Read [`[u8; 4]`] at current position, then advance136	pub fn bytes4(&mut self) -> Result<[u8; 4]> {137		self.read_padright()138	}139140	/// Read [`Vec<u8>`] at current position, then advance141	pub fn bytes(&mut self) -> Result<Vec<u8>> {142		let mut subresult = self.subresult(None)?;143		let length = subresult.uint32()? as usize;144		if subresult.buf.len() < subresult.offset + length {145			return Err(Error::Error(ExitError::OutOfOffset));146		}147		Ok(subresult.buf[subresult.offset..subresult.offset + length].into())148	}149150	/// Read [`string`] at current position, then advance151	pub fn string(&mut self) -> Result<string> {152		string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))153	}154155	/// Read [`u8`] at current position, then advance156	pub fn uint8(&mut self) -> Result<u8> {157		Ok(self.read_padleft::<1>()?[0])158	}159160	/// Read [`u32`] at current position, then advance161	pub fn uint32(&mut self) -> Result<u32> {162		Ok(u32::from_be_bytes(self.read_padleft()?))163	}164165	/// Read [`u128`] at current position, then advance166	pub fn uint128(&mut self) -> Result<u128> {167		Ok(u128::from_be_bytes(self.read_padleft()?))168	}169170	/// Read [`U256`] at current position, then advance171	pub fn uint256(&mut self) -> Result<U256> {172		let buf: [u8; 32] = self.read_padleft()?;173		Ok(U256::from_big_endian(&buf))174	}175176	/// Read [`u64`] at current position, then advance177	pub fn uint64(&mut self) -> Result<u64> {178		Ok(u64::from_be_bytes(self.read_padleft()?))179	}180181	/// Read [`usize`] at current position, then advance182	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]183	pub fn read_usize(&mut self) -> Result<usize> {184		Ok(usize::from_be_bytes(self.read_padleft()?))185	}186187	/// Slice recursive buffer, advance one word for buffer offset188	/// If `size` is [`None`] then [`Self::offset`] and [`Self::subresult_offset`] evals from [`Self::buf`].189	pub fn subresult(&mut self, size: Option<usize>) -> Result<AbiReader<'i>> {190		let subresult_offset = self.subresult_offset;191		let offset = if let Some(size) = size {192			self.offset += size;193			0194		} else {195			self.uint32()? as usize196		};197198		if offset + self.subresult_offset > self.buf.len() {199			return Err(Error::Error(ExitError::InvalidRange));200		}201202		let new_offset = offset + subresult_offset;203		Ok(AbiReader {204			buf: self.buf,205			subresult_offset: new_offset,206			offset: new_offset,207		})208	}209210	/// Notify about readed data portion.211	pub fn bytes_read(&mut self, size: usize) {212		self.subresult_offset += size;213	}214215	/// Is this parser reached end of buffer?216	pub fn is_finished(&self) -> bool {217		self.buf.len() == self.offset218	}219}220221/// Writer for RLP encoded data222#[derive(Default)]223pub struct AbiWriter {224	static_part: Vec<u8>,225	dynamic_part: Vec<(usize, AbiWriter)>,226	had_call: bool,227	is_dynamic: bool,228}229impl AbiWriter {230	/// Initialize internal buffers for output data, assuming no padding required231	pub fn new() -> Self {232		Self::default()233	}234235	/// Initialize internal buffers with data size236	pub fn new_dynamic(is_dynamic: bool) -> Self {237		Self {238			is_dynamic,239			..Default::default()240		}241	}242	/// Initialize internal buffers, inserting method selector at beginning243	pub fn new_call(method_id: u32) -> Self {244		let mut val = Self::new();245		val.static_part.extend(&method_id.to_be_bytes());246		val.had_call = true;247		val248	}249250	fn write_padleft(&mut self, block: &[u8]) {251		assert!(block.len() <= ABI_ALIGNMENT);252		self.static_part253			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);254		self.static_part.extend(block);255	}256257	fn write_padright(&mut self, block: &[u8]) {258		assert!(block.len() <= ABI_ALIGNMENT);259		self.static_part.extend(block);260		self.static_part261			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - block.len()]);262	}263264	/// Write [`H160`] to end of buffer265	pub fn address(&mut self, address: &H160) {266		self.write_padleft(&address.0)267	}268269	/// Write [`bool`] to end of buffer270	pub fn bool(&mut self, value: &bool) {271		self.write_padleft(&[if *value { 1 } else { 0 }])272	}273274	/// Write [`u8`] to end of buffer275	pub fn uint8(&mut self, value: &u8) {276		self.write_padleft(&[*value])277	}278279	/// Write [`u32`] to end of buffer280	pub fn uint32(&mut self, value: &u32) {281		self.write_padleft(&u32::to_be_bytes(*value))282	}283284	/// Write [`u64`] to end of buffer285	pub fn uint64(&mut self, value: &u64) {286		self.write_padleft(&u64::to_be_bytes(*value))287	}288289	/// Write [`u128`] to end of buffer290	pub fn uint128(&mut self, value: &u128) {291		self.write_padleft(&u128::to_be_bytes(*value))292	}293294	/// Write [`U256`] to end of buffer295	pub fn uint256(&mut self, value: &U256) {296		let mut out = [0; 32];297		value.to_big_endian(&mut out);298		self.write_padleft(&out)299	}300301	/// Write [`usize`] to end of buffer302	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]303	pub fn write_usize(&mut self, value: &usize) {304		self.write_padleft(&usize::to_be_bytes(*value))305	}306307	/// Append recursive data, writing pending offset at end of buffer308	pub fn write_subresult(&mut self, result: Self) {309		self.dynamic_part.push((self.static_part.len(), result));310		// Empty block, to be filled later311		self.write_padleft(&[]);312	}313314	fn memory(&mut self, value: &[u8]) {315		let mut sub = Self::new();316		sub.uint32(&(value.len() as u32));317		for chunk in value.chunks(ABI_ALIGNMENT) {318			sub.write_padright(chunk);319		}320		self.write_subresult(sub);321	}322323	/// Append recursive [`str`] at end of buffer324	pub fn string(&mut self, value: &str) {325		self.memory(value.as_bytes())326	}327328	/// Append recursive [`[u8]`] at end of buffer329	pub fn bytes(&mut self, value: &[u8]) {330		self.memory(value)331	}332333	/// Finish writer, concatenating all internal buffers334	pub fn finish(mut self) -> Vec<u8> {335		for (static_offset, part) in self.dynamic_part {336			let part_offset = self.static_part.len()337				- if self.had_call { 4 } else { 0 }338				- if self.is_dynamic { ABI_ALIGNMENT } else { 0 };339340			let encoded_dynamic_offset = usize::to_be_bytes(part_offset);341			let start = static_offset + ABI_ALIGNMENT - encoded_dynamic_offset.len();342			let stop = static_offset + ABI_ALIGNMENT;343			self.static_part[start..stop].copy_from_slice(&encoded_dynamic_offset);344			self.static_part.extend(part.finish())345		}346		self.static_part347	}348}