git.delta.rocks / unique-network / refs/commits / 591c0ace12a9

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#![macro_use]20#![cfg_attr(not(feature = "std"), no_std)]21#[cfg(not(feature = "std"))]22extern crate alloc;2324use abi::{AbiRead, AbiReader, AbiWriter};25pub use evm_coder_procedural::{event_topic, fn_selector};26pub mod abi;27pub use events::{ToLog, ToTopic};28use execution::DispatchInfo;29pub mod execution;30#[macro_use]31pub mod custom_signature;3233/// Derives call enum implementing [`crate::Callable`], [`crate::Weighted`]34/// and [`crate::Call`] from impl block.35///36/// ## Macro syntax37///38/// `#[solidity_interface(name, is, inline_is, events)]`39/// - *name* - used in generated code, and for Call enum name40/// - *is* - used to provide inheritance in Solidity41/// - *inline_is* - same as `is`, but ERC165::SupportsInterface will work differently: For `is` SupportsInterface(A) will return true42///   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)`43///   SupportsInterface(A) will internally create a new interface that combines all methods of A and B, so SupportsInterface(A) will return44///   false.45///46/// `#[weight(value)]`47/// Can be added to every method of impl block, used for deriving [`crate::Weighted`], which48/// is used by substrate bridge.49/// - *value*: expression, which evaluates to weight required to call this method.50/// This expression can use call arguments to calculate non-constant execution time.51/// This expression should evaluate faster than actual execution does, and may provide worse case52/// than one is called.53///54/// `#[solidity_interface(rename_selector)]`55/// - *rename_selector* - by default, selector name will be generated by transforming method name56/// from snake_case to camelCase. Use this option, if other naming convention is required.57/// I.e: method `token_uri` will be automatically renamed to `tokenUri` in selector, but name58/// required by ERC721 standard is `tokenURI`, thus we need to specify `rename_selector = "tokenURI"`59/// explicitly.60///61/// Both contract and contract methods may have doccomments, which will end up in a generated62/// solidity interface file, thus you should use [solidity syntax](https://docs.soliditylang.org/en/latest/natspec-format.html) for writing documentation in this macro63///64/// ## Example65///66/// ```ignore67/// struct SuperContract;68/// struct InlineContract;69/// struct Contract;70///71/// #[derive(ToLog)]72/// enum ContractEvents {73///     Event(#[indexed] uint32),74/// }75///76/// /// @dev This contract provides function to multiply two numbers77/// #[solidity_interface(name = MyContract, is(SuperContract), inline_is(InlineContract))]78/// impl Contract {79///     /// Multiply two numbers80///     /// @param a First number81///     /// @param b Second number82///     /// @return uint32 Product of two passed numbers83///     /// @dev This function returns error in case of overflow84///     #[weight(200 + a + b)]85///     #[solidity_interface(rename_selector = "mul")]86///     fn mul(&mut self, a: uint32, b: uint32) -> Result<uint32> {87///         Ok(a.checked_mul(b).ok_or("overflow")?)88///     }89/// }90/// ```91pub use evm_coder_procedural::solidity_interface;92/// See [`solidity_interface`]93pub use evm_coder_procedural::solidity;94/// See [`solidity_interface`]95pub use evm_coder_procedural::weight;96pub use sha3_const;9798/// Derives [`ToLog`] for enum99///100/// Selectors will be derived from variant names, there is currently no way to have custom naming101/// for them102///103/// `#[indexed]`104/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data105pub use evm_coder_procedural::ToLog;106107// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros108#[doc(hidden)]109pub mod events;110#[doc(hidden)]111#[cfg(feature = "stubgen")]112pub mod solidity;113114/// Solidity type definitions (aliases from solidity name to rust type)115/// To be used in [`solidity_interface`] definitions, to make sure there is no116/// type conflict between Rust code and generated definitions117pub mod types {118	#![allow(non_camel_case_types, missing_docs)]119120	#[cfg(not(feature = "std"))]121	use alloc::{vec::Vec};122	use pallet_evm::account::CrossAccountId;123	use primitive_types::{U256, H160, H256};124	use core::str::from_utf8;125126	use crate::custom_signature::SignatureUnit;127128	pub trait Signature {129		const SIGNATURE: SignatureUnit;130131		fn as_str() -> &'static str {132			from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")133		}134	}135136	impl Signature for bool {137		const SIGNATURE: SignatureUnit = make_signature!(new fixed("bool"));138	}139140	macro_rules! define_simple_type {141		(type $ident:ident = $ty:ty) => {142			pub type $ident = $ty;143			impl Signature for $ty {144				const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($ident)));145			}146		};147	}148149	define_simple_type!(type address = H160);150151	define_simple_type!(type uint8 = u8);152	define_simple_type!(type uint16 = u16);153	define_simple_type!(type uint32 = u32);154	define_simple_type!(type uint64 = u64);155	define_simple_type!(type uint128 = u128);156	define_simple_type!(type uint256 = U256);157	define_simple_type!(type bytes4 = [u8; 4]);158159	define_simple_type!(type topic = H256);160161	#[cfg(not(feature = "std"))]162	define_simple_type!(type string = ::alloc::string::String);163	#[cfg(feature = "std")]164	define_simple_type!(type string = ::std::string::String);165166	#[derive(Default, Debug)]167	pub struct bytes(pub Vec<u8>);168	impl Signature for bytes {169		const SIGNATURE: SignatureUnit = make_signature!(new fixed("bytes"));170	}171172	/// Solidity doesn't have `void` type, however we have special implementation173	/// for empty tuple return type174	pub type void = ();175176	//#region Special types177	/// Makes function payable178	pub type value = U256;179	/// Makes function caller-sensitive180	pub type caller = address;181	//#endregion182183	/// Ethereum typed call message, similar to solidity184	/// `msg` object.185	pub struct Msg<C> {186		pub call: C,187		/// Address of user, which called this contract.188		pub caller: H160,189		/// Payment amount to contract.190		/// Contract should reject payment, if target call is not payable,191		/// and there is no `receiver()` function defined.192		pub value: U256,193	}194195	impl From<Vec<u8>> for bytes {196		fn from(src: Vec<u8>) -> Self {197			Self(src)198		}199	}200201	#[allow(clippy::from_over_into)]202	impl Into<Vec<u8>> for bytes {203		fn into(self) -> Vec<u8> {204			self.0205		}206	}207208	impl bytes {209		#[must_use]210		pub fn len(&self) -> usize {211			self.0.len()212		}213214		#[must_use]215		pub fn is_empty(&self) -> bool {216			self.len() == 0217		}218	}219220	#[derive(Debug, Default)]221	pub struct EthCrossAccount {222		pub(crate) eth: address,223		pub(crate) sub: uint256,224	}225226	impl EthCrossAccount {227		pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self228		where229			T: pallet_evm::account::Config,230			T::AccountId: AsRef<[u8; 32]>,231		{232			if cross_account_id.is_canonical_substrate() {233				Self {234					eth: Default::default(),235					sub: convert_cross_account_to_uint256::<T>(cross_account_id),236				}237			} else {238				Self {239					eth: *cross_account_id.as_eth(),240					sub: Default::default(),241				}242			}243		}244245		pub fn into_sub_cross_account<T>(&self) -> crate::execution::Result<T::CrossAccountId>246		where247			T: pallet_evm::account::Config,248			T::AccountId: From<[u8; 32]>,249		{250			if self.eth == Default::default() && self.sub == Default::default() {251				Err("All fields of cross account is zeroed".into())252			} else if self.eth == Default::default() {253				Ok(convert_uint256_to_cross_account::<T>(self.sub))254			} else if self.sub == Default::default() {255				Ok(T::CrossAccountId::from_eth(self.eth))256			} else {257				Err("All fields of cross account is non zeroed".into())258			}259		}260	}261262	impl Signature for EthCrossAccount {263		const SIGNATURE: SignatureUnit = make_signature!(new fixed("(address,uint256)"));264	}265266	/// Convert `CrossAccountId` to `uint256`.267	pub fn convert_cross_account_to_uint256<T: pallet_evm::account::Config>(268		from: &T::CrossAccountId,269	) -> uint256270	where271		T::AccountId: AsRef<[u8; 32]>,272	{273		let slice = from.as_sub().as_ref();274		uint256::from_big_endian(slice)275	}276277	/// Convert `uint256` to `CrossAccountId`.278	pub fn convert_uint256_to_cross_account<T: pallet_evm::account::Config>(279		from: uint256,280	) -> T::CrossAccountId281	where282		T::AccountId: From<[u8; 32]>,283	{284		let mut new_admin_arr = [0_u8; 32];285		from.to_big_endian(&mut new_admin_arr);286		let account_id = T::AccountId::from(new_admin_arr);287		T::CrossAccountId::from_sub(account_id)288	}289}290291/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro292pub trait Call: Sized {293	/// Parse call buffer into typed call enum294	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;295}296297/// Intended to be used as `#[weight]` output type298/// Should be same between evm-coder and substrate to avoid confusion299///300/// Isn't same thing as gas, some mapping is required between those types301pub type Weight = frame_support::weights::Weight;302303/// In substrate, we have benchmarking, which allows304/// us to not rely on gas metering, but instead predict amount of gas to execute call305pub trait Weighted: Call {306	/// Predict weight of this call307	fn weight(&self) -> DispatchInfo;308}309310/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro311/// on interface implementation, or for externally-owned real EVM contract312pub trait Callable<C: Call> {313	/// Call contract using specified call data314	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;315}316317/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],318/// this structure holds parsed data for ERC165Call subvariant319///320/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every321/// implementing contract322///323/// See <https://eips.ethereum.org/EIPS/eip-165>324#[derive(Debug)]325pub enum ERC165Call {326	/// ERC165 provides single method, which returns true, if contract327	/// implements specified interface328	SupportsInterface {329		/// Requested interface330		interface_id: types::bytes4,331	},332}333334impl ERC165Call {335	/// ERC165 selector is provided by standard336	pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);337}338339impl Call for ERC165Call {340	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {341		if selector != Self::INTERFACE_ID {342			return Ok(None);343		}344		Ok(Some(Self::SupportsInterface {345			interface_id: types::bytes4::abi_read(input)?,346		}))347	}348}349350/// Generate "tests", which will generate solidity code on execution and print it to stdout351/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime352///353/// This macro receives type usage as second argument, but you can use anything as generics,354/// because no bounds are implied355#[macro_export]356macro_rules! generate_stubgen {357	($name:ident, $decl:ty, $is_impl:literal) => {358		#[cfg(feature = "stubgen")]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 event_topic_generation() {390		assert_eq!(391			hex::encode(&event_topic!(Transfer(address, address, uint256))[..]),392			"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",393		);394	}395}