git.delta.rocks / unique-network / refs/commits / 897d53284e18

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 evm_coder_procedural::AbiCoder;97pub use sha3_const;9899/// macro reexports100pub use ethereum;101102/// Derives [`ToLog`] for enum103///104/// Selectors will be derived from variant names, there is currently no way to have custom naming105/// for them106///107/// `#[indexed]`108/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data109pub use evm_coder_procedural::ToLog;110111// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros112#[doc(hidden)]113pub mod events;114#[doc(hidden)]115#[cfg(feature = "stubgen")]116pub mod solidity;117118/// Sealed traits.119pub mod sealed {120	/// Not every type should be directly placed in vec.121	/// Vec encoding is not memory efficient, as every item will be padded122	/// to 32 bytes.123	/// Instead you should use specialized types (`bytes` in case of `Vec<u8>`)124	pub trait CanBePlacedInVec {}125}126127/// Solidity type definitions (aliases from solidity name to rust type)128/// To be used in [`solidity_interface`] definitions, to make sure there is no129/// type conflict between Rust code and generated definitions130pub mod types {131	#![allow(non_camel_case_types, missing_docs)]132133	#[cfg(not(feature = "std"))]134	use alloc::{vec::Vec};135	use primitive_types::{U256, H160, H256};136137	pub type Address = H160;138	pub type Bytes4 = [u8; 4];139	pub type Topic = H256;140141	#[cfg(not(feature = "std"))]142	pub type String = ::alloc::string::String;143	#[cfg(feature = "std")]144	pub type String = ::std::string::String;145146	#[derive(Default, Debug, PartialEq, Eq, Clone)]147	pub struct Bytes(pub Vec<u8>);148149	//#region Special types150	/// Makes function payable151	pub type Value = U256;152	/// Makes function caller-sensitive153	pub type Caller = Address;154	//#endregion155156	/// Ethereum typed call message, similar to solidity157	/// `msg` object.158	pub struct Msg<C> {159		pub call: C,160		/// Address of user, which called this contract.161		pub caller: H160,162		/// Payment amount to contract.163		/// Contract should reject payment, if target call is not payable,164		/// and there is no `receiver()` function defined.165		pub value: U256,166	}167168	impl From<Vec<u8>> for Bytes {169		fn from(src: Vec<u8>) -> Self {170			Self(src)171		}172	}173174	#[allow(clippy::from_over_into)]175	impl Into<Vec<u8>> for Bytes {176		fn into(self) -> Vec<u8> {177			self.0178		}179	}180181	impl Bytes {182		#[must_use]183		pub fn len(&self) -> usize {184			self.0.len()185		}186187		#[must_use]188		pub fn is_empty(&self) -> bool {189			self.len() == 0190		}191	}192}193194/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro195pub trait Call: Sized {196	/// Parse call buffer into typed call enum197	fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;198}199200/// Intended to be used as `#[weight]` output type201/// Should be same between evm-coder and substrate to avoid confusion202///203/// Isn't same thing as gas, some mapping is required between those types204pub type Weight = frame_support::pallet_prelude::Weight;205206/// In substrate, we have benchmarking, which allows207/// us to not rely on gas metering, but instead predict amount of gas to execute call208pub trait Weighted: Call {209	/// Predict weight of this call210	fn weight(&self) -> DispatchInfo;211}212213/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro214/// on interface implementation, or for externally-owned real EVM contract215pub trait Callable<C: Call> {216	/// Call contract using specified call data217	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;218}219220/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],221/// this structure holds parsed data for ERC165Call subvariant222///223/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every224/// implementing contract225///226/// See <https://eips.ethereum.org/EIPS/eip-165>227#[derive(Debug)]228pub enum ERC165Call {229	/// ERC165 provides single method, which returns true, if contract230	/// implements specified interface231	SupportsInterface {232		/// Requested interface233		interface_id: types::Bytes4,234	},235}236237impl ERC165Call {238	/// ERC165 selector is provided by standard239	pub const INTERFACE_ID: types::Bytes4 = u32::to_be_bytes(0x01ffc9a7);240}241242impl Call for ERC165Call {243	fn parse(selector: types::Bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {244		if selector != Self::INTERFACE_ID {245			return Ok(None);246		}247		Ok(Some(Self::SupportsInterface {248			interface_id: types::Bytes4::abi_read(input)?,249		}))250	}251}252253/// Generate "tests", which will generate solidity code on execution and print it to stdout254/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime255///256/// This macro receives type usage as second argument, but you can use anything as generics,257/// because no bounds are implied258#[macro_export]259macro_rules! generate_stubgen {260	($name:ident, $decl:ty, $is_impl:literal) => {261		#[cfg(feature = "stubgen")]262		#[test]263		#[ignore]264		fn $name() {265			use evm_coder::solidity::TypeCollector;266			let mut out = TypeCollector::new();267			<$decl>::generate_solidity_interface(&mut out, $is_impl);268			println!("=== SNIP START ===");269			println!("// SPDX-License-Identifier: OTHER");270			println!("// This code is automatically generated");271			println!();272			println!("pragma solidity >=0.8.0 <0.9.0;");273			println!();274			for b in out.finish() {275				println!("{}", b);276			}277			println!("=== SNIP END ===");278		}279	};280}281282#[cfg(test)]283mod tests {284	use super::*;285286	#[test]287	fn function_selector_generation() {288		assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);289	}290291	#[test]292	fn event_topic_generation() {293		assert_eq!(294			hex::encode(&event_topic!(Transfer(address, address, uint256))[..]),295			"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",296		);297	}298}