git.delta.rocks / unique-network / refs/commits / 78becc5a95dd

14#![cfg_attr(rustfmt, rustfmt_skip)]14#![cfg_attr(rustfmt, rustfmt_skip)]
15#![allow(unused_parens)]15#![allow(unused_parens)]
16#![allow(unused_imports)]16#![allow(unused_imports)]
17#![allow(missing_docs)]
17#![allow(clippy::unnecessary_cast)]18#![allow(clippy::unnecessary_cast)]
1819
19use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};20use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};

1771 "zeroize",1771 "zeroize",
1772]1772]
1773
1774[[package]]
1775name = "darling"
1776version = "0.13.4"
1777source = "registry+https://github.com/rust-lang/crates.io-index"
1778checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
1779dependencies = [
1780 "darling_core",
1781 "darling_macro",
1782]
1783
1784[[package]]
1785name = "darling_core"
1786version = "0.13.4"
1787source = "registry+https://github.com/rust-lang/crates.io-index"
1788checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
1789dependencies = [
1790 "fnv",
1791 "ident_case",
1792 "proc-macro2",
1793 "quote",
1794 "strsim",
1795 "syn",
1796]
1797
1798[[package]]
1799name = "darling_macro"
1800version = "0.13.4"
1801source = "registry+https://github.com/rust-lang/crates.io-index"
1802checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
1803dependencies = [
1804 "darling_core",
1805 "quote",
1806 "syn",
1807]
18081773
1809[[package]]1774[[package]]
1810name = "data-encoding"1775name = "data-encoding"
2207version = "0.1.1"2172version = "0.1.1"
2208dependencies = [2173dependencies = [
2209 "ethereum",2174 "ethereum",
2210 "evm-coder-macros",2175 "evm-coder-procedural",
2211 "evm-core",2176 "evm-core",
2212 "hex",2177 "hex",
2213 "hex-literal",2178 "hex-literal",
2216]2181]
22172182
2218[[package]]2183[[package]]
2219name = "evm-coder-macros"2184name = "evm-coder-procedural"
2220version = "0.1.0"2185version = "0.2.0"
2221dependencies = [2186dependencies = [
2222 "Inflector",2187 "Inflector",
2223 "darling",
2224 "hex",2188 "hex",
2225 "proc-macro2",2189 "proc-macro2",
2226 "quote",2190 "quote",
2227 "sha3 0.9.1",2191 "sha3 0.10.2",
2228 "syn",2192 "syn",
2229]2193]
22302194
3428 "winapi",3392 "winapi",
3429]3393]
3430
3431[[package]]
3432name = "ident_case"
3433version = "1.0.1"
3434source = "registry+https://github.com/rust-lang/crates.io-index"
3435checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
34363394
3437[[package]]3395[[package]]
3438name = "idna"3396name = "idna"

5edition = "2021"5edition = "2021"
66
7[dependencies]7[dependencies]
8# evm-coder reexports those proc-macro
8evm-coder-macros = { path = "../evm-coder-macros" }9evm-coder-procedural = { path = "./procedural" }
10# Evm uses primitive-types for H160, H256 and others
9primitive-types = { version = "0.11.1", default-features = false }11primitive-types = { version = "0.11.1", default-features = false }
10hex-literal = "0.3.3"12# Evm doesn't have reexports for log and others
11ethereum = { version = "0.12.0", default-features = false }13ethereum = { version = "0.12.0", default-features = false }
14# Error types for execution
12evm-core = { default-features = false, git = "https://github.com/uniquenetwork/evm", branch = "unique-polkadot-v0.9.27" }15evm-core = { default-features = false, git = "https://github.com/uniquenetwork/evm", branch = "unique-polkadot-v0.9.27" }
16# We have tuple-heavy code in solidity.rs
13impl-trait-for-tuples = "0.2.1"17impl-trait-for-tuples = "0.2.2"
1418
15[dev-dependencies]19[dev-dependencies]
20# We want to assert some large binary blobs equality in tests
16hex = "0.4.3"21hex = "0.4.3"
22hex-literal = "0.3.4"
1723
18[features]24[features]
19default = ["std"]25default = ["std"]

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17//! TODO: I misunterstood therminology, abi IS rlp encoded, so17//! Implementation of EVM RLP reader/writer
18//! this module should be replaced with rlp crate
1918
20#![allow(dead_code)]19#![allow(dead_code)]
2120
3231
33const ABI_ALIGNMENT: usize = 32;32const ABI_ALIGNMENT: usize = 32;
3433
34/// View into RLP data, which provides method to read typed items from it
35#[derive(Clone)]35#[derive(Clone)]
36pub struct AbiReader<'i> {36pub struct AbiReader<'i> {
37	buf: &'i [u8],37	buf: &'i [u8],
38	subresult_offset: usize,38	subresult_offset: usize,
39	offset: usize,39	offset: usize,
40}40}
41impl<'i> AbiReader<'i> {41impl<'i> AbiReader<'i> {
42	/// Start reading RLP buffer, assuming there is no padding bytes
42	pub fn new(buf: &'i [u8]) -> Self {43	pub fn new(buf: &'i [u8]) -> Self {
43		Self {44		Self {
44			buf,45			buf,
45			subresult_offset: 0,46			subresult_offset: 0,
46			offset: 0,47			offset: 0,
47		}48		}
48	}49	}
50	/// Start reading RLP buffer, parsing first 4 bytes as selector
49	pub fn new_call(buf: &'i [u8]) -> Result<(types::bytes4, Self)> {51	pub fn new_call(buf: &'i [u8]) -> Result<(types::bytes4, Self)> {
50		if buf.len() < 4 {52		if buf.len() < 4 {
51			return Err(Error::Error(ExitError::OutOfOffset));53			return Err(Error::Error(ExitError::OutOfOffset));
109		)111		)
110	}112	}
111113
114	/// Read [`H160`] at current position, then advance
112	pub fn address(&mut self) -> Result<H160> {115	pub fn address(&mut self) -> Result<H160> {
113		Ok(H160(self.read_padleft()?))116		Ok(H160(self.read_padleft()?))
114	}117	}
115118
119	/// Read [`bool`] at current position, then advance
116	pub fn bool(&mut self) -> Result<bool> {120	pub fn bool(&mut self) -> Result<bool> {
117		let data: [u8; 1] = self.read_padleft()?;121		let data: [u8; 1] = self.read_padleft()?;
118		match data[0] {122		match data[0] {
122		}126		}
123	}127	}
124128
129	/// Read [`[u8; 4]`] at current position, then advance
125	pub fn bytes4(&mut self) -> Result<[u8; 4]> {130	pub fn bytes4(&mut self) -> Result<[u8; 4]> {
126		self.read_padright()131		self.read_padright()
127	}132	}
128133
134	/// Read [`Vec<u8>`] at current position, then advance
129	pub fn bytes(&mut self) -> Result<Vec<u8>> {135	pub fn bytes(&mut self) -> Result<Vec<u8>> {
130		let mut subresult = self.subresult()?;136		let mut subresult = self.subresult()?;
131		let length = subresult.read_usize()?;137		let length = subresult.uint32()? as usize;
132		if subresult.buf.len() < subresult.offset + length {138		if subresult.buf.len() < subresult.offset + length {
133			return Err(Error::Error(ExitError::OutOfOffset));139			return Err(Error::Error(ExitError::OutOfOffset));
134		}140		}
135		Ok(subresult.buf[subresult.offset..subresult.offset + length].into())141		Ok(subresult.buf[subresult.offset..subresult.offset + length].into())
136	}142	}
143
144	/// Read [`string`] at current position, then advance
137	pub fn string(&mut self) -> Result<string> {145	pub fn string(&mut self) -> Result<string> {
138		string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))146		string::from_utf8(self.bytes()?).map_err(|_| Error::Error(ExitError::InvalidRange))
139	}147	}
140148
149	/// Read [`u8`] at current position, then advance
141	pub fn uint8(&mut self) -> Result<u8> {150	pub fn uint8(&mut self) -> Result<u8> {
142		Ok(self.read_padleft::<1>()?[0])151		Ok(self.read_padleft::<1>()?[0])
143	}152	}
144153
154	/// Read [`u32`] at current position, then advance
145	pub fn uint32(&mut self) -> Result<u32> {155	pub fn uint32(&mut self) -> Result<u32> {
146		Ok(u32::from_be_bytes(self.read_padleft()?))156		Ok(u32::from_be_bytes(self.read_padleft()?))
147	}157	}
148158
159	/// Read [`u128`] at current position, then advance
149	pub fn uint128(&mut self) -> Result<u128> {160	pub fn uint128(&mut self) -> Result<u128> {
150		Ok(u128::from_be_bytes(self.read_padleft()?))161		Ok(u128::from_be_bytes(self.read_padleft()?))
151	}162	}
152163
164	/// Read [`U256`] at current position, then advance
153	pub fn uint256(&mut self) -> Result<U256> {165	pub fn uint256(&mut self) -> Result<U256> {
154		let buf: [u8; 32] = self.read_padleft()?;166		let buf: [u8; 32] = self.read_padleft()?;
155		Ok(U256::from_big_endian(&buf))167		Ok(U256::from_big_endian(&buf))
156	}168	}
157169
170	/// Read [`u64`] at current position, then advance
158	pub fn uint64(&mut self) -> Result<u64> {171	pub fn uint64(&mut self) -> Result<u64> {
159		Ok(u64::from_be_bytes(self.read_padleft()?))172		Ok(u64::from_be_bytes(self.read_padleft()?))
160	}173	}
161174
175	/// Read [`usize`] at current position, then advance
176	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]
162	pub fn read_usize(&mut self) -> Result<usize> {177	pub fn read_usize(&mut self) -> Result<usize> {
163		Ok(usize::from_be_bytes(self.read_padleft()?))178		Ok(usize::from_be_bytes(self.read_padleft()?))
164	}179	}
165180
181	/// Slice recursive buffer, advance one word for buffer offset
166	fn subresult(&mut self) -> Result<AbiReader<'i>> {182	fn subresult(&mut self) -> Result<AbiReader<'i>> {
167		let offset = self.read_usize()?;183		let offset = self.uint32()? as usize;
168		if offset + self.subresult_offset > self.buf.len() {184		if offset + self.subresult_offset > self.buf.len() {
169			return Err(Error::Error(ExitError::InvalidRange));185			return Err(Error::Error(ExitError::InvalidRange));
170		}186		}
175		})191		})
176	}192	}
177193
194	/// Is this parser reached end of buffer?
178	pub fn is_finished(&self) -> bool {195	pub fn is_finished(&self) -> bool {
179		self.buf.len() == self.offset196		self.buf.len() == self.offset
180	}197	}
181}198}
182199
200/// Writer for RLP encoded data
183#[derive(Default)]201#[derive(Default)]
184pub struct AbiWriter {202pub struct AbiWriter {
185	static_part: Vec<u8>,203	static_part: Vec<u8>,
186	dynamic_part: Vec<(usize, AbiWriter)>,204	dynamic_part: Vec<(usize, AbiWriter)>,
187	had_call: bool,205	had_call: bool,
188}206}
189impl AbiWriter {207impl AbiWriter {
208	/// Initialize internal buffers for output data, assuming no padding required
190	pub fn new() -> Self {209	pub fn new() -> Self {
191		Self::default()210		Self::default()
192	}211	}
212	/// Initialize internal buffers, inserting method selector at beginning
193	pub fn new_call(method_id: u32) -> Self {213	pub fn new_call(method_id: u32) -> Self {
194		let mut val = Self::new();214		let mut val = Self::new();
195		val.static_part.extend(&method_id.to_be_bytes());215		val.static_part.extend(&method_id.to_be_bytes());
211			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - bytes.len()]);231			.extend(&[0; ABI_ALIGNMENT][0..ABI_ALIGNMENT - bytes.len()]);
212	}232	}
213233
234	/// Write [`H160`] to end of buffer
214	pub fn address(&mut self, address: &H160) {235	pub fn address(&mut self, address: &H160) {
215		self.write_padleft(&address.0)236		self.write_padleft(&address.0)
216	}237	}
217238
239	/// Write [`bool`] to end of buffer
218	pub fn bool(&mut self, value: &bool) {240	pub fn bool(&mut self, value: &bool) {
219		self.write_padleft(&[if *value { 1 } else { 0 }])241		self.write_padleft(&[if *value { 1 } else { 0 }])
220	}242	}
221243
244	/// Write [`u8`] to end of buffer
222	pub fn uint8(&mut self, value: &u8) {245	pub fn uint8(&mut self, value: &u8) {
223		self.write_padleft(&[*value])246		self.write_padleft(&[*value])
224	}247	}
225248
249	/// Write [`u32`] to end of buffer
226	pub fn uint32(&mut self, value: &u32) {250	pub fn uint32(&mut self, value: &u32) {
227		self.write_padleft(&u32::to_be_bytes(*value))251		self.write_padleft(&u32::to_be_bytes(*value))
228	}252	}
229253
254	/// Write [`u128`] to end of buffer
230	pub fn uint128(&mut self, value: &u128) {255	pub fn uint128(&mut self, value: &u128) {
231		self.write_padleft(&u128::to_be_bytes(*value))256		self.write_padleft(&u128::to_be_bytes(*value))
232	}257	}
233258
259	/// Write [`U256`] to end of buffer
234	pub fn uint256(&mut self, value: &U256) {260	pub fn uint256(&mut self, value: &U256) {
235		let mut out = [0; 32];261		let mut out = [0; 32];
236		value.to_big_endian(&mut out);262		value.to_big_endian(&mut out);
237		self.write_padleft(&out)263		self.write_padleft(&out)
238	}264	}
239265
266	/// Write [`usize`] to end of buffer
267	#[deprecated = "dangerous, as usize may have different width in wasm and native execution"]
240	pub fn write_usize(&mut self, value: &usize) {268	pub fn write_usize(&mut self, value: &usize) {
241		self.write_padleft(&usize::to_be_bytes(*value))269		self.write_padleft(&usize::to_be_bytes(*value))
242	}270	}
243271
272	/// Append recursive data, writing pending offset at end of buffer
244	pub fn write_subresult(&mut self, result: Self) {273	pub fn write_subresult(&mut self, result: Self) {
245		self.dynamic_part.push((self.static_part.len(), result));274		self.dynamic_part.push((self.static_part.len(), result));
246		// Empty block, to be filled later275		// Empty block, to be filled later
247		self.write_padleft(&[]);276		self.write_padleft(&[]);
248	}277	}
249278
250	pub fn memory(&mut self, value: &[u8]) {279	fn memory(&mut self, value: &[u8]) {
251		let mut sub = Self::new();280		let mut sub = Self::new();
252		sub.write_usize(&value.len());281		sub.uint32(&(value.len() as u32));
253		for chunk in value.chunks(ABI_ALIGNMENT) {282		for chunk in value.chunks(ABI_ALIGNMENT) {
254			sub.write_padright(chunk);283			sub.write_padright(chunk);
255		}284		}
256		self.write_subresult(sub);285		self.write_subresult(sub);
257	}286	}
258287
288	/// Append recursive [`str`] at end of buffer
259	pub fn string(&mut self, value: &str) {289	pub fn string(&mut self, value: &str) {
260		self.memory(value.as_bytes())290		self.memory(value.as_bytes())
261	}291	}
262292
293	/// Append recursive [`[u8]`] at end of buffer
263	pub fn bytes(&mut self, value: &[u8]) {294	pub fn bytes(&mut self, value: &[u8]) {
264		self.memory(value)295		self.memory(value)
265	}296	}
266297
298	/// Finish writer, concatenating all internal buffers
267	pub fn finish(mut self) -> Vec<u8> {299	pub fn finish(mut self) -> Vec<u8> {
268		for (static_offset, part) in self.dynamic_part {300		for (static_offset, part) in self.dynamic_part {
269			let part_offset = self.static_part.len() - self.had_call.then(|| 4).unwrap_or(0);301			let part_offset = self.static_part.len() - self.had_call.then(|| 4).unwrap_or(0);
278	}310	}
279}311}
280312
313/// [`AbiReader`] implements reading of many types, but it should
314/// be limited to types defined in spec
315///
316/// As this trait can't be made sealed,
317/// instead of having `impl AbiRead for T`, we have `impl AbiRead<T> for AbiReader`
281pub trait AbiRead<T> {318pub trait AbiRead<T> {
319	/// Read item from current position, advanding decoder
282	fn abi_read(&mut self) -> Result<T>;320	fn abi_read(&mut self) -> Result<T>;
283}321}
284322
318{356{
319	fn abi_read(&mut self) -> Result<Vec<R>> {357	fn abi_read(&mut self) -> Result<Vec<R>> {
320		let mut sub = self.subresult()?;358		let mut sub = self.subresult()?;
321		let size = sub.read_usize()?;359		let size = sub.uint32()? as usize;
322		sub.subresult_offset = sub.offset;360		sub.subresult_offset = sub.offset;
323		let mut out = Vec::with_capacity(size);361		let mut out = Vec::with_capacity(size);
324		for _ in 0..size {362		for _ in 0..size {
366impl_tuples! {A B C D E F G H I}404impl_tuples! {A B C D E F G H I}
367impl_tuples! {A B C D E F G H I J}405impl_tuples! {A B C D E F G H I J}
368406
407/// For questions about inability to provide custom implementations,
408/// see [`AbiRead`]
369pub trait AbiWrite {409pub trait AbiWrite {
410	/// Write value to end of specified encoder
370	fn abi_write(&self, writer: &mut AbiWriter);411	fn abi_write(&self, writer: &mut AbiWriter);
412	/// Specialization for [`crate::solidity_interface`] implementation,
413	/// see comment in `impl AbiWrite for ResultWithPostInfo`
371	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {414	fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {
372		let mut writer = AbiWriter::new();415		let mut writer = AbiWriter::new();
373		self.abi_write(&mut writer);416		self.abi_write(&mut writer);
374		Ok(writer.into())417		Ok(writer.into())
375	}418	}
376}419}
377420
421/// This particular AbiWrite implementation should be split to another trait,
422/// which only implements `to_result`, but due to lack of specialization feature
423/// in stable Rust, we can't have blanket impl of this trait `for T where T: AbiWrite`,
424/// so here we abusing default trait methods for it
378impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {425impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {
379	// this particular AbiWrite implementation should be split to another trait,
380	// which only implements [`to_result`]
381	//
382	// But due to lack of specialization feature in stable Rust, we can't have
383	// blanket impl of this trait `for T where T: AbiWrite`, so here we abusing
384	// default trait methods for it
385	fn abi_write(&self, _writer: &mut AbiWriter) {426	fn abi_write(&self, _writer: &mut AbiWriter) {
386		debug_assert!(false, "shouldn't be called, see comment")427		debug_assert!(false, "shouldn't be called, see comment")
387	}428	}
432	fn abi_write(&self, _writer: &mut AbiWriter) {}473	fn abi_write(&self, _writer: &mut AbiWriter) {}
433}474}
434475
476/// Helper macros to parse reader into variables
477#[deprecated]
435#[macro_export]478#[macro_export]
436macro_rules! abi_decode {479macro_rules! abi_decode {
437	($reader:expr, $($name:ident: $typ:ident),+ $(,)?) => {480	($reader:expr, $($name:ident: $typ:ident),+ $(,)?) => {
441	}484	}
442}485}
486
487/// Helper macros to construct RLP-encoded buffer
488#[deprecated]
443#[macro_export]489#[macro_export]
444macro_rules! abi_encode {490macro_rules! abi_encode {
445	($($typ:ident($value:expr)),* $(,)?) => {{491	($($typ:ident($value:expr)),* $(,)?) => {{

1919
20use crate::types::*;20use crate::types::*;
2121
22/// Implementation of this trait should not be written manually,
23/// instead use [`crate::ToLog`] proc macros.
24///
25/// See also [`evm_coder_procedural::ToLog`], [solidity docs on events](https://docs.soliditylang.org/en/develop/contracts.html#events)
22pub trait ToLog {26pub trait ToLog {
27	/// Convert event to [`ethereum::Log`].
28	/// Because event by itself doesn't contains current contract
29	/// address, it should be specified manually.
23	fn to_log(&self, contract: H160) -> Log;30	fn to_log(&self, contract: H160) -> Log;
24}31}
2532
33/// Only items implementing `ToTopic` may be used as `#[indexed]` field
34/// in [`crate::ToLog`] macro usage.
35///
36/// See also (solidity docs on events)[<https://docs.soliditylang.org/en/develop/contracts.html#events>]
26pub trait ToTopic {37pub trait ToTopic {
38	/// Convert value to topic to be used in [`ethereum::Log`]
27	fn to_topic(&self) -> H256;39	fn to_topic(&self) -> H256;
28}40}
2941

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
16
17//! Contract execution related types
1618
17#[cfg(not(feature = "std"))]19#[cfg(not(feature = "std"))]
18use alloc::string::{String, ToString};20use alloc::string::{String, ToString};
2224
23use crate::Weight;25use crate::Weight;
2426
27/// Execution error, should be convertible between EVM and Substrate.
25#[derive(Debug, Clone)]28#[derive(Debug, Clone)]
26pub enum Error {29pub enum Error {
30	/// Non-fatal contract error occured
27	Revert(String),31	Revert(String),
32	/// EVM fatal error
28	Fatal(ExitFatal),33	Fatal(ExitFatal),
34	/// EVM normal error
29	Error(ExitError),35	Error(ExitError),
30}36}
3137
38	}44	}
39}45}
4046
47/// To be used in [`crate::solidity_interface`] implementation.
41pub type Result<T> = core::result::Result<T, Error>;48pub type Result<T> = core::result::Result<T, Error>;
4249
50/// Static information collected from [`crate::weight`].
43pub struct DispatchInfo {51pub struct DispatchInfo {
52	/// Statically predicted call weight
44	pub weight: Weight,53	pub weight: Weight,
45}54}
4655
55	}64	}
56}65}
5766
67/// Weight information that is only available post dispatch.
68/// Note: This can only be used to reduce the weight or fee, not increase it.
58#[derive(Default, Clone)]69#[derive(Default, Clone)]
59pub struct PostDispatchInfo {70pub struct PostDispatchInfo {
71	/// Actual weight consumed by call
60	actual_weight: Option<Weight>,72	actual_weight: Option<Weight>,
61}73}
6274
63impl PostDispatchInfo {75impl PostDispatchInfo {
76	/// Calculate amount to be returned back to user
64	pub fn calc_unspent(&self, info: &DispatchInfo) -> Weight {77	pub fn calc_unspent(&self, info: &DispatchInfo) -> Weight {
65		info.weight - self.calc_actual_weight(info)78		info.weight - self.calc_actual_weight(info)
66	}79	}
6780
81	/// Calculate actual consumed weight, saturating to weight reported
82	/// pre-dispatch
68	pub fn calc_actual_weight(&self, info: &DispatchInfo) -> Weight {83	pub fn calc_actual_weight(&self, info: &DispatchInfo) -> Weight {
69		if let Some(actual_weight) = self.actual_weight {84		if let Some(actual_weight) = self.actual_weight {
70			actual_weight.min(info.weight)85			actual_weight.min(info.weight)
74	}89	}
75}90}
7691
92/// Wrapper for PostDispatchInfo and any user-provided data
77#[derive(Clone)]93#[derive(Clone)]
78pub struct WithPostDispatchInfo<T> {94pub struct WithPostDispatchInfo<T> {
95	/// User provided data
79	pub data: T,96	pub data: T,
97	/// Info known after dispatch
80	pub post_info: PostDispatchInfo,98	pub post_info: PostDispatchInfo,
81}99}
82100
89	}107	}
90}108}
91109
110/// Return type of items in [`crate::solidity_interface`] definition
92pub type ResultWithPostInfo<T> =111pub type ResultWithPostInfo<T> =
93	core::result::Result<WithPostDispatchInfo<T>, WithPostDispatchInfo<Error>>;112	core::result::Result<WithPostDispatchInfo<T>, WithPostDispatchInfo<Error>>;
94113

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17#![doc = include_str!("../README.md")]
18#![deny(missing_docs)]
17#![cfg_attr(not(feature = "std"), no_std)]19#![cfg_attr(not(feature = "std"), no_std)]
18#[cfg(not(feature = "std"))]20#[cfg(not(feature = "std"))]
19extern crate alloc;21extern crate alloc;
2022
21use abi::{AbiRead, AbiReader, AbiWriter};23use abi::{AbiRead, AbiReader, AbiWriter};
22pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, weight, ToLog};24pub use evm_coder_procedural::{event_topic, fn_selector};
23pub mod abi;25pub mod abi;
24pub mod events;
25pub use events::ToLog;26pub use events::{ToLog, ToTopic};
26use execution::DispatchInfo;27use execution::DispatchInfo;
27pub mod execution;28pub mod execution;
29
30/// Derives call enum implementing [`crate::Callable`], [`crate::Weighted`]
31/// and [`crate::Call`] from impl block.
32///
33/// ## Macro syntax
34///
35/// `#[solidity_interface(name, is, inline_is, events)]`
36/// - *name* - used in generated code, and for Call enum name
37/// - *is* - used to provide inheritance in Solidity
38/// - *inline_is* - same as `is`, but ERC165::SupportsInterface will work differently: For `is` SupportsInterface(A) will return true
39///   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)`
40///   SupportsInterface(A) will internally create a new interface that combines all methods of A and B, so SupportsInterface(A) will return
41///   false.
42///
43/// `#[weight(value)]`
44/// Can be added to every method of impl block, used for deriving [`crate::Weighted`], which
45/// is used by substrate bridge.
46/// - *value*: expression, which evaluates to weight required to call this method.
47/// This expression can use call arguments to calculate non-constant execution time.
48/// This expression should evaluate faster than actual execution does, and may provide worse case
49/// than one is called.
50///
51/// `#[solidity_interface(rename_selector)]`
52/// - *rename_selector* - by default, selector name will be generated by transforming method name
53/// from snake_case to camelCase. Use this option, if other naming convention is required.
54/// I.e: method `token_uri` will be automatically renamed to `tokenUri` in selector, but name
55/// required by ERC721 standard is `tokenURI`, thus we need to specify `rename_selector = "tokenURI"`
56/// explicitly.
57///
58/// Both contract and contract methods may have doccomments, which will end up in a generated
59/// solidity interface file, thus you should use [solidity syntax](https://docs.soliditylang.org/en/latest/natspec-format.html) for writing documentation in this macro
60///
61/// ## Example
62///
63/// ```ignore
64/// struct SuperContract;
65/// struct InlineContract;
66/// struct Contract;
67///
68/// #[derive(ToLog)]
69/// enum ContractEvents {
70///     Event(#[indexed] uint32),
71/// }
72///
73/// /// @dev This contract provides function to multiply two numbers
74/// #[solidity_interface(name = MyContract, is(SuperContract), inline_is(InlineContract))]
75/// impl Contract {
76///     /// Multiply two numbers
77/// 	/// @param a First number
78/// 	/// @param b Second number
79/// 	/// @return uint32 Product of two passed numbers
80/// 	/// @dev This function returns error in case of overflow
81///     #[weight(200 + a + b)]
82///     #[solidity_interface(rename_selector = "mul")]
83///     fn mul(&mut self, a: uint32, b: uint32) -> Result<uint32> {
84///         Ok(a.checked_mul(b).ok_or("overflow")?)
85///     }
86/// }
87/// ```
88pub use evm_coder_procedural::solidity_interface;
89/// See [`solidity_interface`]
90pub use evm_coder_procedural::solidity;
91/// See [`solidity_interface`]
92pub use evm_coder_procedural::weight;
93
94/// Derives [`ToLog`] for enum
95///
96/// Selectors will be derived from variant names, there is currently no way to have custom naming
97/// for them
98///
99/// `#[indexed]`
100/// Marks this field as indexed, so it will appear in [`ethereum::Log`] topics instead of data
101pub use evm_coder_procedural::ToLog;
102
103// Api of those modules shouldn't be consumed directly, it is only exported for usage in proc macros
104#[doc(hidden)]
105pub mod events;
106#[doc(hidden)]
28pub mod solidity;107pub mod solidity;
29108
30/// Solidity type definitions109/// Solidity type definitions (aliases from solidity name to rust type)
110/// To be used in [`solidity_interface`] definitions, to make sure there is no
111/// type conflict between Rust code and generated definitions
31pub mod types {112pub mod types {
32	#![allow(non_camel_case_types)]113	#![allow(non_camel_case_types, missing_docs)]
33114
34	#[cfg(not(feature = "std"))]115	#[cfg(not(feature = "std"))]
35	use alloc::{vec::Vec};116	use alloc::{vec::Vec};
54	pub type string = ::std::string::String;135	pub type string = ::std::string::String;
55	pub type bytes = Vec<u8>;136	pub type bytes = Vec<u8>;
56137
138	/// Solidity doesn't have `void` type, however we have special implementation
139	/// for empty tuple return type
57	pub type void = ();140	pub type void = ();
58141
59	//#region Special types142	//#region Special types
63	pub type caller = address;146	pub type caller = address;
64	//#endregion147	//#endregion
65148
149	/// Ethereum typed call message, similar to solidity
150	/// `msg` object.
66	pub struct Msg<C> {151	pub struct Msg<C> {
67		pub call: C,152		pub call: C,
153		/// Address of user, which called this contract.
68		pub caller: H160,154		pub caller: H160,
155		/// Payment amount to contract.
156		/// Contract should reject payment, if target call is not payable,
157		/// and there is no `receiver()` function defined.
69		pub value: U256,158		pub value: U256,
70	}159	}
71}160}
72161
162/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro
73pub trait Call: Sized {163pub trait Call: Sized {
164	/// Parse call buffer into typed call enum
74	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;165	fn parse(selector: types::bytes4, input: &mut AbiReader) -> execution::Result<Option<Self>>;
75}166}
76167
168/// Intended to be used as `#[weight]` output type
169/// Should be same between evm-coder and substrate to avoid confusion
170///
171/// Isn't same thing as gas, some mapping is required between those types
77pub type Weight = u64;172pub type Weight = u64;
78173
174/// In substrate, we have benchmarking, which allows
175/// us to not rely on gas metering, but instead predict amount of gas to execute call
79pub trait Weighted: Call {176pub trait Weighted: Call {
177	/// Predict weight of this call
80	fn weight(&self) -> DispatchInfo;178	fn weight(&self) -> DispatchInfo;
81}179}
82180
181/// Type callable with ethereum message, may be implemented by [`solidity_interface`] macro
182/// on interface implementation, or for externally-owned real EVM contract
83pub trait Callable<C: Call> {183pub trait Callable<C: Call> {
184	/// Call contract using specified call data
84	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;185	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;
85}186}
86187
87/// Implementation is implicitly provided for all interfaces188/// Implementation of ERC165 is implicitly generated for all interfaces in [`solidity_interface`],
189/// this structure holds parsed data for ERC165Call subvariant
88///190///
89/// Note: no Callable implementation is provided191/// Note: no [`Callable`] implementation is provided, call implementation is inlined into every
192/// implementing contract
193///
194/// See <https://eips.ethereum.org/EIPS/eip-165>
90#[derive(Debug)]195#[derive(Debug)]
91pub enum ERC165Call {196pub enum ERC165Call {
197	/// ERC165 provides single method, which returns true, if contract
198	/// implements specified interface
92	SupportsInterface { interface_id: types::bytes4 },199	SupportsInterface {
200		/// Requested interface
201		interface_id: types::bytes4,
202	},
93}203}
94204
95impl ERC165Call {205impl ERC165Call {
206	/// ERC165 selector is provided by standard
96	pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);207	pub const INTERFACE_ID: types::bytes4 = u32::to_be_bytes(0x01ffc9a7);
97}208}
98209