git.delta.rocks / unique-network / refs/commits / 6afd9fe97b2d

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#![doc = include_str!("../README.md")]18// #![deny(missing_docs)]19#![warn(missing_docs)]20#![macro_use]21#![cfg_attr(not(feature = "std"), no_std)]22#[cfg(not(feature = "std"))]23extern crate alloc;2425use abi::{AbiRead, AbiReader, AbiWriter};26pub use evm_coder_procedural::{event_topic, fn_selector};27pub mod abi;28pub use events::{ToLog, ToTopic};29use execution::DispatchInfo;30pub mod execution;31#[macro_use]32pub mod custom_signature;3334/// Derives call enum implementing [`crate::Callable`], [`crate::Weighted`]35/// and [`crate::Call`] from impl block.36///37/// ## Macro syntax38///39/// `#[solidity_interface(name, is, inline_is, events)]`40/// - *name* - used in generated code, and for Call enum name41/// - *is* - used to provide inheritance in Solidity42/// - *inline_is* - same as `is`, but ERC165::SupportsInterface will work differently: For `is` SupportsInterface(A) will return true43///   if A is one of the interfaces the contract is inherited from (e.g. B is created as `is(A)`). If B is created as `inline_is(A)`44///   SupportsInterface(A) will internally create a new interface that combines all methods of A and B, so SupportsInterface(A) will return45///   false.46///47/// `#[weight(value)]`48/// Can be added to every method of impl block, used for deriving [`crate::Weighted`], which49/// is used by substrate bridge.50/// - *value*: expression, which evaluates to weight required to call this method.51/// This expression can use call arguments to calculate non-constant execution time.52/// This expression should evaluate faster than actual execution does, and may provide worse case53/// than one is called.54///55/// `#[solidity_interface(rename_selector)]`56/// - *rename_selector* - by default, selector name will be generated by transforming method name57/// from snake_case to camelCase. Use this option, if other naming convention is required.58/// I.e: method `token_uri` will be automatically renamed to `tokenUri` in selector, but name59/// required by ERC721 standard is `tokenURI`, thus we need to specify `rename_selector = "tokenURI"`60/// explicitly.61///62/// Both contract and contract methods may have doccomments, which will end up in a generated63/// solidity interface file, thus you should use [solidity syntax](https://docs.soliditylang.org/en/latest/natspec-format.html) for writing documentation in this macro64///65/// ## Example66///67/// ```ignore68/// struct SuperContract;69/// struct InlineContract;70/// struct Contract;71///72/// #[derive(ToLog)]73/// enum ContractEvents {74///     Event(#[indexed] uint32),75/// }76///77/// /// @dev This contract provides function to multiply two numbers78/// #[solidity_interface(name = MyContract, is(SuperContract), inline_is(InlineContract))]79/// impl Contract {80///     /// Multiply two numbers81///     /// @param a First number82///     /// @param b Second number83///     /// @return uint32 Product of two passed numbers84///     /// @dev This function returns error in case of overflow85///     #[weight(200 + a + b)]86///     #[solidity_interface(rename_selector = "mul")]87///     fn mul(&mut self, a: uint32, b: uint32) -> Result<uint32> {88///         Ok(a.checked_mul(b).ok_or("overflow")?)89///     }90/// }91/// ```92pub use evm_coder_procedural::solidity_interface;93/// See [`solidity_interface`]94pub use evm_coder_procedural::solidity;95/// See [`solidity_interface`]96pub use evm_coder_procedural::weight;97pub use const_format;98pub use sha3_const;99100/// Derives [`ToLog`] for enum101///102/// Selectors will be derived from variant names, there is currently no way to have custom naming103/// for them104///105/// `#[indexed]`106/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data107pub use evm_coder_procedural::ToLog;108109// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros110#[doc(hidden)]111pub mod events;112#[doc(hidden)]113pub mod solidity;114115/// Solidity type definitions (aliases from solidity name to rust type)116/// To be used in [`solidity_interface`] definitions, to make sure there is no117/// type conflict between Rust code and generated definitions118pub mod types {119	#![allow(non_camel_case_types, missing_docs)]120121	#[cfg(not(feature = "std"))]122	use alloc::{vec::Vec};123	use pallet_evm::account::CrossAccountId;124	use primitive_types::{U256, H160, H256};125	use core::str::from_utf8;126127	use crate::custom_signature::{SignatureUnit, SIGNATURE_SIZE_LIMIT};128129	pub trait Signature {130		const SIGNATURE: SignatureUnit;131132		fn as_str() -> &'static str {133			from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")134		}135	}136137	impl Signature for bool {138		make_signature!(new fixed("bool"));139	}140141	macro_rules! define_simple_type {142		(type $ident:ident = $ty:ty) => {143			pub type $ident = $ty;144			impl Signature for $ty {145				make_signature!(new fixed(stringify!($ident)));146			}147		};148	}149150	define_simple_type!(type address = H160);151152	define_simple_type!(type uint8 = u8);153	define_simple_type!(type uint16 = u16);154	define_simple_type!(type uint32 = u32);155	define_simple_type!(type uint64 = u64);156	define_simple_type!(type uint128 = u128);157	define_simple_type!(type uint256 = U256);158	define_simple_type!(type bytes4 = [u8; 4]);159160	define_simple_type!(type topic = H256);161162	#[cfg(not(feature = "std"))]163	define_simple_type!(type string = ::alloc::string::String);164	#[cfg(feature = "std")]165	define_simple_type!(type string = ::std::string::String);166167	#[derive(Default, Debug)]168	pub struct bytes(pub Vec<u8>);169	impl Signature for bytes {170		make_signature!(new fixed("bytes"));171	}172173	/// Solidity doesn't have `void` type, however we have special implementation174	/// for empty tuple return type175	pub type void = ();176177	//#region Special types178	/// Makes function payable179	pub type value = U256;180	/// Makes function caller-sensitive181	pub type caller = address;182	//#endregion183184	/// Ethereum typed call message, similar to solidity185	/// `msg` object.186	pub struct Msg<C> {187		pub call: C,188		/// Address of user, which called this contract.189		pub caller: H160,190		/// Payment amount to contract.191		/// Contract should reject payment, if target call is not payable,192		/// and there is no `receiver()` function defined.193		pub value: U256,194	}195196	impl From<Vec<u8>> for bytes {197		fn from(src: Vec<u8>) -> Self {198			Self(src)199		}200	}201202	#[allow(clippy::from_over_into)]203	impl Into<Vec<u8>> for bytes {204		fn into(self) -> Vec<u8> {205			self.0206		}207	}208209	impl bytes {210		#[must_use]211		pub fn len(&self) -> usize {212			self.0.len()213		}214215		#[must_use]216		pub fn is_empty(&self) -> bool {217			self.len() == 0218		}219	}220221	#[derive(Debug, Default)]222	pub struct EthCrossAccount {223		pub(crate) eth: address,224		pub(crate) sub: uint256,225	}226227	impl EthCrossAccount {228		pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self229		where230			T: pallet_evm::account::Config,231			T::AccountId: AsRef<[u8; 32]>,232		{233			if cross_account_id.is_canonical_substrate() {234				Self {235					eth: Default::default(),236					sub: convert_cross_account_to_uint256::<T>(cross_account_id),237				}238			} else {239				Self {240					eth: *cross_account_id.as_eth(),241					sub: Default::default(),242				}243			}244		}245246		pub fn into_sub_cross_account<T>(&self) -> crate::execution::Result<T::CrossAccountId>247		where248			T: pallet_evm::account::Config,249			T::AccountId: From<[u8; 32]>,250		{251			if self.eth == Default::default() && self.sub == Default::default() {252				Err("All fields of cross account is zeroed".into())253			} else if self.eth == Default::default() {254				Ok(convert_uint256_to_cross_account::<T>(self.sub))255			} else if self.sub == Default::default() {256				Ok(T::CrossAccountId::from_eth(self.eth))257			} else {258				Err("All fields of cross account is non zeroed".into())259			}260		}261	}262263	impl Signature for EthCrossAccount {264		make_signature!(new fixed("(address,uint256)"));265	}266267	/// Convert `CrossAccountId` to `uint256`.268	pub fn convert_cross_account_to_uint256<T: pallet_evm::account::Config>(269		from: &T::CrossAccountId,270	) -> uint256271	where272		T::AccountId: AsRef<[u8; 32]>,273	{274		let slice = from.as_sub().as_ref();275		uint256::from_big_endian(slice)276	}277278	/// Convert `uint256` to `CrossAccountId`.279	pub fn convert_uint256_to_cross_account<T: pallet_evm::account::Config>(280		from: uint256,281	) -> T::CrossAccountId282	where283		T::AccountId: From<[u8; 32]>,284	{285		let mut new_admin_arr = [0_u8; 32];286		from.to_big_endian(&mut new_admin_arr);287		let account_id = T::AccountId::from(new_admin_arr);288		T::CrossAccountId::from_sub(account_id)289	}290}291292/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro293pub trait Call: Sized {294	/// Parse call buffer into typed call enum295	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;296}297298/// Intended to be used as `#[weight]` output type299/// Should be same between evm-coder and substrate to avoid confusion300///301/// Isn't same thing as gas, some mapping is required between those types302pub type Weight = frame_support::weights::Weight;303304/// In substrate, we have benchmarking, which allows305/// us to not rely on gas metering, but instead predict amount of gas to execute call306pub trait Weighted: Call {307	/// Predict weight of this call308	fn weight(&self) -> DispatchInfo;309}310311/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro312/// on interface implementation, or for externally-owned real EVM contract313pub trait Callable<C: Call> {314	/// Call contract using specified call data315	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;316}317318/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],319/// this structure holds parsed data for ERC165Call subvariant320///321/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every322/// implementing contract323///324/// See <https://eips.ethereum.org/EIPS/eip-165>325#[derive(Debug)]326pub enum ERC165Call {327	/// ERC165 provides single method, which returns true, if contract328	/// implements specified interface329	SupportsInterface {330		/// Requested interface331		interface_id: types::bytes4,332	},333}334335impl ERC165Call {336	/// ERC165 selector is provided by standard337	pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);338}339340impl Call for ERC165Call {341	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {342		if selector != Self::INTERFACE_ID {343			return Ok(None);344		}345		Ok(Some(Self::SupportsInterface {346			interface_id: input.abi_read()?,347		}))348	}349}350351/// Generate "tests", which will generate solidity code on execution and print it to stdout352/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime353///354/// This macro receives type usage as second argument, but you can use anything as generics,355/// because no bounds are implied356#[macro_export]357macro_rules! generate_stubgen {358	($name:ident, $decl:ty, $is_impl:literal) => {359		#[test]360		#[ignore]361		fn $name() {362			use evm_coder::solidity::TypeCollector;363			let mut out = TypeCollector::new();364			<$decl>::generate_solidity_interface(&mut out, $is_impl);365			println!("=== SNIP START ===");366			println!("// SPDX-License-Identifier: OTHER");367			println!("// This code is automatically generated");368			println!();369			println!("pragma solidity >=0.8.0 <0.9.0;");370			println!();371			for b in out.finish() {372				println!("{}", b);373			}374			println!("=== SNIP END ===");375		}376	};377}378379#[cfg(test)]380mod tests {381	use super::*;382383	#[test]384	fn function_selector_generation() {385		assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);386	}387388	// #[test]389	// fn function_selector_generation_1() {390	// 	assert_eq!(391	// 		fn_selector!(transferFromCrossAccountToCrossAccount(392	// 			EthCrossAccount,393	// 			EthCrossAccount,394	// 			uint256395	// 		)),396	// 		2543295963397	// 	);398	// }399400	#[test]401	fn event_topic_generation() {402		assert_eq!(403			hex::encode(&event_topic!(Transfer(address, address, uint256))[..]),404			"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",405		);406	}407}