git.delta.rocks / unique-network / refs/commits / 68058b4890a6

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#![cfg_attr(not(feature = "std"), no_std)]20#[cfg(not(feature = "std"))]21extern crate alloc;2223use abi::{AbiRead, AbiReader, AbiWriter};24pub use evm_coder_procedural::{event_topic, fn_selector};25pub mod abi;26pub use events::{ToLog, ToTopic};27use execution::DispatchInfo;28pub mod execution;2930/// Derives call enum implementing [`crate::Callable`], [`crate::Weighted`]31/// and [`crate::Call`] from impl block.32///33/// ## Macro syntax34///35/// `#[solidity_interface(name, is, inline_is, events)]`36/// - *name* - used in generated code, and for Call enum name37/// - *is* - used to provide call inheritance, not found methods will be delegated to all contracts38/// specified in is/inline_is39/// - *inline_is* - same as is, but selectors for passed contracts will be used by derived ERC16540/// implementation41///42/// `#[weight(value)]`43/// Can be added to every method of impl block, used for deriving [`crate::Weighted`], which44/// is used by substrate bridge.45/// - *value*: expression, which evaluates to weight required to call this method.46/// This expression can use call arguments to calculate non-constant execution time.47/// This expression should evaluate faster than actual execution does, and may provide worser case48/// than one is called.49///50/// `#[solidity_interface(rename_selector)]`51/// - *rename_selector* - by default, selector name will be generated by transforming method name52/// from snake_case to camelCase. Use this option, if other naming convention is required.53/// I.e: method `token_uri` will be automatically renamed to `tokenUri` in selector, but name54/// required by ERC721 standard is `tokenURI`, thus we need to specify `rename_selector = "tokenURI"`55/// explicitly.56///57/// Both contract and contract methods may have doccomments, which will end up in a generated58/// solidity interface file, thus you should use [solidity syntax](https://docs.soliditylang.org/en/latest/natspec-format.html) for writing documentation in this macro59///60/// ## Example61///62/// ```ignore63/// struct SuperContract;64/// struct InlineContract;65/// struct Contract;66///67/// #[derive(ToLog)]68/// enum ContractEvents {69///     Event(#[indexed] uint32),70/// }71///72/// /// @dev This contract provides function to multiply two numbers73/// #[solidity_interface(name = MyContract, is(SuperContract), inline_is(InlineContract))]74/// impl Contract {75///     /// Multiply two numbers76/// 	/// @param a First number77/// 	/// @param b Second number78/// 	/// @return uint32 Product of two passed numbers79/// 	/// @dev This function returns error in case of overflow80///     #[weight(200 + a + b)]81///     #[solidity_interface(rename_selector = "mul")]82///     fn mul(&mut self, a: uint32, b: uint32) -> Result<uint32> {83///         Ok(a.checked_mul(b).ok_or("overflow")?)84///     }85/// }86/// ```87pub use evm_coder_procedural::solidity_interface;88/// See [`solidity_interface`]89pub use evm_coder_procedural::solidity;90/// See [`solidity_interface`]91pub use evm_coder_procedural::weight;9293/// Derives [`ToLog`] for enum94///95/// Selectors will be derived from variant names, there is currently no way to have custom naming96/// for them97///98/// `#[indexed]`99/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data100pub use evm_coder_procedural::ToLog;101102// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros103#[doc(hidden)]104pub mod events;105#[doc(hidden)]106pub mod solidity;107108/// Solidity type definitions (aliases from solidity name to rust type)109/// To be used in [`solidity_interface`] definitions, to make sure there is no110/// type conflict between Rust code and generated definitions111pub mod types {112	#![allow(non_camel_case_types, missing_docs)]113114	#[cfg(not(feature = "std"))]115	use alloc::{vec::Vec};116	use primitive_types::{U256, H160, H256};117118	pub type address = H160;119120	pub type uint8 = u8;121	pub type uint16 = u16;122	pub type uint32 = u32;123	pub type uint64 = u64;124	pub type uint128 = u128;125	pub type uint256 = U256;126127	pub type bytes4 = [u8; 4];128129	pub type topic = H256;130131	#[cfg(not(feature = "std"))]132	pub type string = ::alloc::string::String;133	#[cfg(feature = "std")]134	pub type string = ::std::string::String;135	pub type bytes = Vec<u8>;136137	/// Solidity doesn't have `void` type, however we have special implementation138	/// for empty tuple return type139	pub type void = ();140141	//#region Special types142	/// Makes function payable143	pub type value = U256;144	/// Makes function caller-sensitive145	pub type caller = address;146	//#endregion147148	/// Ethereum typed call message, similar to solidity149	/// `msg` object.150	pub struct Msg<C> {151		pub call: C,152		/// Address of user, which called this contract.153		pub caller: H160,154		/// Payment amount to contract.155		/// Contract should reject payment, if target call is not payable,156		/// and there is no `receiver()` function defined.157		pub value: U256,158	}159}160161/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro162pub trait Call: Sized {163	/// Parse call buffer into typed call enum164	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;165}166167/// Intended to be used as `#[weight]` output type168/// Should be same between evm-coder and substrate to avoid confusion169///170/// Isn't same thing as gas, some mapping is required between those types171pub type Weight = u64;172173/// In substrate, we have benchmarking, which allows174/// us to not rely on gas metering, but instead predict amount of gas to execute call175pub trait Weighted: Call {176	/// Predict weight of this call177	fn weight(&self) -> DispatchInfo;178}179180/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro181/// on interface implementation, or for externally-owned real EVM contract182pub trait Callable<C: Call> {183	/// Call contract using specified call data184	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;185}186187/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],188/// this structure holds parsed data for ERC165Call subvariant189///190/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every191/// implementing contract192///193/// See <https://eips.ethereum.org/EIPS/eip-165>194#[derive(Debug)]195pub enum ERC165Call {196	/// ERC165 provides single method, which returns true, if contract197	/// implements specified interface198	SupportsInterface {199		/// Requested interface200		interface_id: types::bytes4,201	},202}203204impl ERC165Call {205	/// ERC165 selector is provided by standard206	pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);207}208209impl Call for ERC165Call {210	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>> {211		if selector != Self::INTERFACE_ID {212			return Ok(None);213		}214		Ok(Some(Self::SupportsInterface {215			interface_id: input.abi_read()?,216		}))217	}218}219220/// Generate "tests", which will generate solidity code on execution and print it to stdout221/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime222///223/// This macro receives type usage as second argument, but you can use anything as generics,224/// because no bounds are implied225#[macro_export]226macro_rules! generate_stubgen {227	($name:ident, $decl:ty, $is_impl:literal) => {228		#[test]229		#[ignore]230		fn $name() {231			use evm_coder::solidity::TypeCollector;232			let mut out = TypeCollector::new();233			<$decl>::generate_solidity_interface(&mut out, $is_impl);234			println!("=== SNIP START ===");235			println!("// SPDX-License-Identifier: OTHER");236			println!("// This code is automatically generated");237			println!();238			println!("pragma solidity >=0.8.0 <0.9.0;");239			println!();240			for b in out.finish() {241				println!("{}", b);242			}243			println!("=== SNIP END ===");244		}245	};246}247248#[cfg(test)]249mod tests {250	use super::*;251252	#[test]253	fn function_selector_generation() {254		assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);255	}256257	#[test]258	fn event_topic_generation() {259		assert_eq!(260			hex::encode(&event_topic!(Transfer(address, address, uint256))[..]),261			"ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",262		);263	}264}