git.delta.rocks / unique-network / refs/commits / e1eb64a31d34

1.PHONY: _eth_codegen1.PHONY: _help
2_eth_codegen:2_help:
3	@echo "regenerate_solidity - generate stubs/interfaces for contracts defined in native (via evm-coder)"
4	@echo "evm_stubs - recompile contract stubs"
5	@echo "bench - run frame-benchmarking"
6	@echo "  bench-evm-migration"
7	@echo "  bench-nft"
38
4.PHONY: regenerate_solidity9.PHONY: regenerate_solidity
5regenerate_solidity:10regenerate_solidity:

6363
642. Remove all installed toolchains with `rustup toolchain list` and `rustup toolchain uninstall <toolchain>`.642. Remove all installed toolchains with `rustup toolchain list` and `rustup toolchain uninstall <toolchain>`.
6565
663. Install install nightly 2021-03-01 and make it default:663. Install install nightly 2021-06-28 and make it default:
6767
68```bash68```bash
69rustup toolchain install nightly-2021-03-0169rustup toolchain install nightly-2021-06-28
70rustup default nightly-2021-03-0170rustup default nightly-2021-06-28
71```71```
7272
734. Add wasm target for nightly toolchain:734. Add wasm target for nightly toolchain:
7474
75```bash75```bash
76rustup target add wasm32-unknown-unknown --toolchain nightly-2021-03-0176rustup target add wasm32-unknown-unknown --toolchain nightly-2021-06-28
77```77```
7878
795. Build:795. Build:
135135
136## Building and Running as Parachain locally136## Building and Running as Parachain locally
137137
138Rust toolchain: nightly-2021-04-23138Rust toolchain: nightly-2021-06-28
139Note: checkout this project and polkadot project (see below) in the sibling folders (both under the same folder)139Note: checkout this project and polkadot project (see below) in the sibling folders (both under the same folder)
140140
141### Build relay141### Build relay
142142
143```143```
144git clone https://github.com/paritytech/polkadot.git144git clone https://github.com/paritytech/polkadot.git
145cd polkadot145cd polkadot
146git checkout aa386760146git checkout release-v0.9.9
147cargo build --release147cargo build --release
148```148```
149149
208208
209First of all, add rust toolchain and make it default.209First of all, add rust toolchain and make it default.
210```bash210```bash
211rustup target add wasm32-unknown-unknown --toolchain nightly-2020-10-01211rustup target add wasm32-unknown-unknown --toolchain nightly-2021-06-28
212```212```
213213
214Then in "/node/src" run build command below214Then in "/node/src" run build command below
215```bash215```bash
216cargo +nightly-2020-10-01 build --release --features runtime-benchmarks216cargo +nightly-2021-06-28 build --release --features runtime-benchmarks
217```217```
218218
219Run benchmark219Run benchmark
257Uncomment following lies:257Uncomment following lies:
2581. In node/rpc/Cargo.toml2581. In node/rpc/Cargo.toml
259```259```
260# pallet-contracts-rpc = { version = "3.0", git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.8' }260# pallet-contracts-rpc = { version = "3.0", git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.9' }
261```261```
262262
2632. In node/rpc/src/lib.rs2632. In node/rpc/src/lib.rs
280    # [dependencies.pallet-contracts]280    # [dependencies.pallet-contracts]
281    # git = 'https://github.com/paritytech/substrate.git'281    # git = 'https://github.com/paritytech/substrate.git'
282    # default-features = false282    # default-features = false
283    # branch = 'polkadot-v0.9.8'283    # branch = 'polkadot-v0.9.9'
284    # version = '3.0.0'284    # version = '3.0.0'
285285
286    # [dependencies.pallet-contracts-primitives]286    # [dependencies.pallet-contracts-primitives]
287    # git = 'https://github.com/paritytech/substrate.git'287    # git = 'https://github.com/paritytech/substrate.git'
288    # default-features = false288    # default-features = false
289    # branch = 'polkadot-v0.9.8'289    # branch = 'polkadot-v0.9.9'
290    # version = '3.0.0'290    # version = '3.0.0'
291291
292    # [dependencies.pallet-contracts-rpc-runtime-api]292    # [dependencies.pallet-contracts-rpc-runtime-api]
293    # git = 'https://github.com/paritytech/substrate.git'293    # git = 'https://github.com/paritytech/substrate.git'
294    # default-features = false294    # default-features = false
295    # branch = 'polkadot-v0.9.8'295    # branch = 'polkadot-v0.9.9'
296    # version = '3.0.0'296    # version = '3.0.0'
297...297...
298    # pallet-contract-helpers = { path = '../pallets/contract-helpers', default-features = false, version = '0.1.0' }298    # pallet-contract-helpers = { path = '../pallets/contract-helpers', default-features = false, version = '0.1.0' }

1#![allow(dead_code)]1#![allow(dead_code)]
22
3use quote::quote;3use quote::quote;
4use darling::FromMeta;4use darling::{FromMeta, ToTokens};
5use inflector::cases;5use inflector::cases;
6use std::fmt::Write;6use std::fmt::Write;
7use syn::{7use syn::{
8	FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Meta, NestedMeta, PatType, Path,8	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
9	ReturnType, Type, spanned::Spanned,9	NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,
10};10};
1111
12use crate::{12use crate::{
13	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,13	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,
14	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,14	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,
15	snake_ident_to_screaming,15	snake_ident_to_screaming,
16};16};
77	fn expand_generator(&self) -> proc_macro2::TokenStream {77	fn expand_generator(&self) -> proc_macro2::TokenStream {
78		let pascal_call_name = &self.pascal_call_name;78		let pascal_call_name = &self.pascal_call_name;
79		quote! {79		quote! {
80			#pascal_call_name::generate_solidity_interface(out_set, is_impl);80			#pascal_call_name::generate_solidity_interface(tc, is_impl);
81		}81		}
82	}82	}
8383
84	fn expand_event_generator(&self) -> proc_macro2::TokenStream {84	fn expand_event_generator(&self) -> proc_macro2::TokenStream {
85		let name = &self.name;85		let name = &self.name;
86		quote! {86		quote! {
87			#name::generate_solidity_interface(out_set, is_impl);87			#name::generate_solidity_interface(tc, is_impl);
88		}88		}
89	}89	}
90}90}
121	rename_selector: Option<String>,121	rename_selector: Option<String>,
122}122}
123
124enum AbiType {
125	// type
126	Plain(Ident),
127	// (type1,type2)
128	Tuple(Vec<AbiType>),
129	// type[]
130	Vec(Box<AbiType>),
131	// type[20]
132	Array(Box<AbiType>, usize),
133}
134impl AbiType {
135	fn try_from(value: &Type) -> syn::Result<Self> {
136		let value = Self::try_maybe_special_from(value)?;
137		if value.is_special() {
138			return Err(syn::Error::new(value.span(), "unexpected special type"));
139		}
140		Ok(value)
141	}
142	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {
143		match value {
144			Type::Array(arr) => {
145				let wrapped = AbiType::try_from(&arr.elem)?;
146				match &arr.len {
147					Expr::Lit(l) => match &l.lit {
148						Lit::Int(i) => {
149							let num = i.base10_parse::<usize>()?;
150							Ok(AbiType::Array(Box::new(wrapped), num as usize))
151						}
152						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),
153					},
154					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),
155				}
156			}
157			Type::Path(_) => {
158				let path = parse_path(value)?;
159				let segment = parse_path_segment(path)?;
160				if segment.ident == "Vec" {
161					let args = match &segment.arguments {
162						PathArguments::AngleBracketed(e) => e,
163						_ => {
164							return Err(syn::Error::new(
165								segment.arguments.span(),
166								"missing Vec generic",
167							))
168						}
169					};
170					let args = &args.args;
171					if args.len() != 1 {
172						return Err(syn::Error::new(
173							args.span(),
174							"expected only one generic for vec",
175						));
176					}
177					let arg = args.first().unwrap();
178
179					let ty = match arg {
180						GenericArgument::Type(ty) => ty,
181						_ => {
182							return Err(syn::Error::new(
183								arg.span(),
184								"expected first generic to be type",
185							))
186						}
187					};
188
189					let wrapped = AbiType::try_from(ty)?;
190					Ok(Self::Vec(Box::new(wrapped)))
191				} else {
192					if !segment.arguments.is_empty() {
193						return Err(syn::Error::new(
194							segment.arguments.span(),
195							"unexpected generic arguments for non-vec type",
196						));
197					}
198					Ok(Self::Plain(segment.ident.clone()))
199				}
200			}
201			Type::Tuple(t) => {
202				let mut out = Vec::with_capacity(t.elems.len());
203				for el in t.elems.iter() {
204					out.push(AbiType::try_from(el)?)
205				}
206				Ok(Self::Tuple(out))
207			}
208			_ => Err(syn::Error::new(
209				value.span(),
210				"unexpected type, only arrays, plain types and tuples are supported",
211			)),
212		}
213	}
214	fn is_value(&self) -> bool {
215		match self {
216			Self::Plain(v) if v == "value" => true,
217			_ => false,
218		}
219	}
220	fn is_caller(&self) -> bool {
221		match self {
222			Self::Plain(v) if v == "caller" => true,
223			_ => false,
224		}
225	}
226	fn is_special(&self) -> bool {
227		self.is_caller() || self.is_value()
228	}
229	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {
230		match self {
231			AbiType::Plain(t) => {
232				write!(buf, "{}", t)
233			}
234			AbiType::Tuple(t) => {
235				write!(buf, "(")?;
236				for (i, t) in t.iter().enumerate() {
237					if i != 0 {
238						write!(buf, ",")?;
239					}
240					t.selector_ty_buf(buf)?;
241				}
242				write!(buf, ")")
243			}
244			AbiType::Vec(v) => {
245				v.selector_ty_buf(buf)?;
246				write!(buf, "[]")
247			}
248			AbiType::Array(v, len) => {
249				v.selector_ty_buf(buf)?;
250				write!(buf, "[{}]", len)
251			}
252		}
253	}
254	fn selector_ty(&self) -> String {
255		let mut out = String::new();
256		self.selector_ty_buf(&mut out).expect("no fmt error");
257		out
258	}
259}
260impl ToTokens for AbiType {
261	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
262		match self {
263			AbiType::Plain(t) => tokens.extend(quote! {#t}),
264			AbiType::Tuple(t) => {
265				tokens.extend(quote! {(
266					#(#t),*
267				)});
268			}
269			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),
270			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),
271		}
272	}
273}
123274
124struct MethodArg {275struct MethodArg {
125	name: Ident,276	name: Ident,
126	camel_name: String,277	camel_name: String,
127	ty: Ident,278	ty: AbiType,
128}279}
129impl MethodArg {280impl MethodArg {
130	fn try_from(value: &PatType) -> syn::Result<Self> {281	fn try_from(value: &PatType) -> syn::Result<Self> {
131		let name = parse_ident_from_pat(&value.pat)?.clone();282		let name = parse_ident_from_pat(&value.pat)?.clone();
132		Ok(Self {283		Ok(Self {
133			camel_name: cases::camelcase::to_camel_case(&name.to_string()),284			camel_name: cases::camelcase::to_camel_case(&name.to_string()),
134			name,285			name,
135			ty: parse_ident_from_type(&value.ty, false)?.clone(),286			ty: AbiType::try_maybe_special_from(&value.ty)?,
136		})287		})
137	}288	}
138	fn is_value(&self) -> bool {289	fn is_value(&self) -> bool {
139		self.ty == "value"290		self.ty.is_value()
140	}291	}
141	fn is_caller(&self) -> bool {292	fn is_caller(&self) -> bool {
142		self.ty == "caller"293		self.ty.is_caller()
143	}294	}
144	fn is_special(&self) -> bool {295	fn is_special(&self) -> bool {
145		self.is_value() || self.is_caller()296		self.ty.is_special()
146	}297	}
147	fn selector_ty(&self) -> &Ident {298	fn selector_ty(&self) -> String {
148		assert!(!self.is_special());299		assert!(!self.is_special());
149		&self.ty300		self.ty.selector_ty()
150	}301	}
151302
152	fn expand_call_def(&self) -> proc_macro2::TokenStream {303	fn expand_call_def(&self) -> proc_macro2::TokenStream {
419			.iter()570			.iter()
420			.filter(|a| !a.is_special())571			.filter(|a| !a.is_special())
421			.map(MethodArg::expand_solidity_argument);572			.map(MethodArg::expand_solidity_argument);
573		let selector = format!("{} {:0>8x}", self.selector_str, self.selector);
422574
423		quote! {575		quote! {
424			SolidityFunction {576			SolidityFunction {
577				selector: #selector,
425				name: #camel_name,578				name: #camel_name,
426				mutability: #mutability,579				mutability: #mutability,
427				args: (580				args: (
544						)*697						)*
545					)698					)
546				}699				}
547				pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {700				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
548					use evm_coder::solidity::*;701					use evm_coder::solidity::*;
549					use core::fmt::Write;702					use core::fmt::Write;
550					let interface = SolidityInterface {703					let interface = SolidityInterface {
559						)*),712						)*),
560					};713					};
561					if is_impl {714					if is_impl {
562						out_set.insert("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());715						tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
563					} else {716					} else {
564						out_set.insert("// Common stubs holder\ninterface Dummy {\n}\n".into());717						tc.collect("// Common stubs holder\ninterface Dummy {\n}\n".into());
565					}718					}
566					#(719					#(
567						#solidity_generators720						#solidity_generators
576					if #solidity_name.starts_with("Inline") {729					if #solidity_name.starts_with("Inline") {
577						out.push_str("// Inline\n");730						out.push_str("// Inline\n");
578					}731					}
579					let _ = interface.format(is_impl, &mut out);732					let _ = interface.format(is_impl, &mut out, tc);
580					out_set.insert(out);733					tc.collect(out);
581				}734				}
582			}735			}
583			impl ::evm_coder::Call for #call_name {736			impl ::evm_coder::Call for #call_name {

179					#consts179					#consts
180				)*180				)*
181181
182				pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {182				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
183					use evm_coder::solidity::*;183					use evm_coder::solidity::*;
184					use core::fmt::Write;184					use core::fmt::Write;
185					let interface = SolidityInterface {185					let interface = SolidityInterface {
191					};191					};
192					let mut out = string::new();192					let mut out = string::new();
193					out.push_str("// Inline\n");193					out.push_str("// Inline\n");
194					let _ = interface.format(is_impl, &mut out);194					let _ = interface.format(is_impl, &mut out, tc);
195					out_set.insert(out);195					tc.collect(out);
196				}196				}
197			}197			}
198198

55
6[dependencies]6[dependencies]
7evm-coder-macros = { path = "../evm-coder-macros" }7evm-coder-macros = { path = "../evm-coder-macros" }
8primitive-types = { version = "0.9", default-features = false }8primitive-types = { version = "0.10.1", default-features = false }
9hex-literal = "0.3"9hex-literal = "0.3.3"
10ethereum = { version = "0.7.1", default-features = false }10ethereum = { version = "0.9.0", default-features = false }
11evm-core = { default-features = false, git = "https://github.com/uniquenetwork/evm.git", branch="precompile-output-parachain" }11evm-core = { default-features = false, git = "https://github.com/uniquenetwork/evm.git", branch="precompile-output-parachain" }
12impl-trait-for-tuples = "0.2.1"12impl-trait-for-tuples = "0.2.1"
1313

211		self.memory(value.as_bytes())211		self.memory(value.as_bytes())
212	}212	}
213
214	pub fn bytes(&mut self, value: &[u8]) {
215		self.memory(value)
216	}
213217
214	pub fn finish(mut self) -> Vec<u8> {218	pub fn finish(mut self) -> Vec<u8> {
215		for (static_offset, part) in self.dynamic_part {219		for (static_offset, part) in self.dynamic_part {
247impl_abi_readable!(bool, bool);251impl_abi_readable!(bool, bool);
248impl_abi_readable!(string, string);252impl_abi_readable!(string, string);
253
254mod sealed {
255	/// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
256	pub trait CanBePlacedInVec {}
257}
258
259impl sealed::CanBePlacedInVec for U256 {}
260impl sealed::CanBePlacedInVec for string {}
261impl sealed::CanBePlacedInVec for H160 {}
262
263impl<R: sealed::CanBePlacedInVec> AbiRead<Vec<R>> for AbiReader<'_>
264where
265	Self: AbiRead<R>,
266{
267	fn abi_read(&mut self) -> Result<Vec<R>> {
268		let mut sub = self.subresult()?;
269		let size = sub.read_usize()?;
270		sub.subresult_offset = sub.offset;
271		let mut out = Vec::with_capacity(size);
272		for _ in 0..size {
273			out.push(<Self as AbiRead<R>>::abi_read(&mut sub)?);
274		}
275		Ok(out)
276	}
277}
278
279macro_rules! impl_tuples {
280	($($ident:ident)+) => {
281		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
282		impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
283		where
284			$(Self: AbiRead<$ident>),+
285		{
286			fn abi_read(&mut self) -> Result<($($ident,)+)> {
287				let mut subresult = self.subresult()?;
288				Ok((
289					$(<Self as AbiRead<$ident>>::abi_read(&mut subresult)?,)+
290				))
291			}
292		}
293	};
294}
295
296impl_tuples! {A}
297impl_tuples! {A B}
298impl_tuples! {A B C}
299impl_tuples! {A B C D}
300impl_tuples! {A B C D E}
301impl_tuples! {A B C D E F}
302impl_tuples! {A B C D E F G}
303impl_tuples! {A B C D E F G H}
304impl_tuples! {A B C D E F G H I}
305impl_tuples! {A B C D E F G H I J}
249306
250pub trait AbiWrite {307pub trait AbiWrite {
251	fn abi_write(&self, writer: &mut AbiWriter);308	fn abi_write(&self, writer: &mut AbiWriter);
273		writer.string(self)330		writer.string(self)
274	}331	}
275}332}
333impl AbiWrite for &Vec<u8> {
334	fn abi_write(&self, writer: &mut AbiWriter) {
335		writer.bytes(self)
336	}
337}
276338
277impl AbiWrite for () {339impl AbiWrite for () {
278	fn abi_write(&self, _writer: &mut AbiWriter) {}340	fn abi_write(&self, _writer: &mut AbiWriter) {}
308370
309#[cfg(test)]371#[cfg(test)]
310pub mod test {372pub mod test {
373	use crate::{
374		abi::AbiRead,
375		types::{string, uint256},
376	};
377
311	use super::{AbiReader, AbiWriter};378	use super::{AbiReader, AbiWriter};
312	use hex_literal::hex;379	use hex_literal::hex;
356		assert_eq!(decoder.string().unwrap(), "Test URI");423		assert_eq!(decoder.string().unwrap(), "Test URI");
357	}424	}
425
426	#[test]
427	fn mint_bulk() {
428		let (call, mut decoder) = AbiReader::new_call(&hex!(
429			"
430				36543006
431				00000000000000000000000053744e6da587ba10b32a2554d2efdcd985bc27a3 // address
432				0000000000000000000000000000000000000000000000000000000000000040 // offset of (uint256, string)[]
433				0000000000000000000000000000000000000000000000000000000000000003 // length of (uint256, string)[]
434
435				0000000000000000000000000000000000000000000000000000000000000060 // offset of first elem
436				00000000000000000000000000000000000000000000000000000000000000e0 // offset of second elem
437				0000000000000000000000000000000000000000000000000000000000000160 // offset of third elem
438
439				0000000000000000000000000000000000000000000000000000000000000001 // first token id?   					#60
440				0000000000000000000000000000000000000000000000000000000000000040 // offset of string
441				000000000000000000000000000000000000000000000000000000000000000a // size of string
442				5465737420555249203000000000000000000000000000000000000000000000 // string
443
444				000000000000000000000000000000000000000000000000000000000000000b // second token id? Why ==11?			#e0
445				0000000000000000000000000000000000000000000000000000000000000040 // offset of string
446				000000000000000000000000000000000000000000000000000000000000000a // size of string
447				5465737420555249203100000000000000000000000000000000000000000000 // string
448
449				000000000000000000000000000000000000000000000000000000000000000c // third token id?  Why ==12?			#160
450				0000000000000000000000000000000000000000000000000000000000000040 // offset of string
451				000000000000000000000000000000000000000000000000000000000000000a // size of string
452				5465737420555249203200000000000000000000000000000000000000000000 // string
453			"
454		))
455		.unwrap();
456		assert_eq!(call, 0x36543006);
457		let _ = decoder.address().unwrap();
458		let data =
459			<AbiReader<'_> as AbiRead<Vec<(uint256, string)>>>::abi_read(&mut decoder).unwrap();
460		assert_eq!(
461			data,
462			vec![
463				(1.into(), "Test URI 0".to_string()),
464				(11.into(), "Test URI 1".to_string()),
465				(12.into(), "Test URI 2".to_string())
466			]
467		);
468	}
358}469}
359470

67		#[test]67		#[test]
68		#[ignore]68		#[ignore]
69		fn $name() {69		fn $name() {
70			use sp_std::collections::btree_set::BTreeSet;70			use evm_coder::solidity::TypeCollector;
71			let mut out = BTreeSet::new();71			let mut out = TypeCollector::new();
72			$decl::generate_solidity_interface(&mut out, $is_impl);72			$decl::generate_solidity_interface(&mut out, $is_impl);
73			println!("=== SNIP START ===");73			println!("=== SNIP START ===");
74			println!("// SPDX-License-Identifier: OTHER");74			println!("// SPDX-License-Identifier: OTHER");
75			println!("// This code is automatically generated");75			println!("// This code is automatically generated");
76			println!();76			println!();
77			println!("pragma solidity >=0.8.0 <0.9.0;");77			println!("pragma solidity >=0.8.0 <0.9.0;");
78			println!();78			println!();
79			for b in out {79			for b in out.finish() {
80				println!("{}", b);80				println!("{}", b);
81			}81			}
82			println!("=== SNIP END ===");82			println!("=== SNIP END ===");

1#[cfg(not(feature = "std"))]1#[cfg(not(feature = "std"))]
2use alloc::{string::String};2use alloc::{
3	string::String,
4	vec::Vec,
5	collections::{BTreeSet, BTreeMap},
6	format,
7};
8#[cfg(feature = "std")]
9use std::collections::{BTreeSet, BTreeMap};
3use core::{fmt, marker::PhantomData};10use core::{
11	fmt::{self, Write},
12	marker::PhantomData,
13	cell::{Cell, RefCell},
14};
4use impl_trait_for_tuples::impl_for_tuples;15use impl_trait_for_tuples::impl_for_tuples;
5use crate::types::*;16use crate::types::*;
17
18#[derive(Default)]
19pub struct TypeCollector {
20	structs: RefCell<BTreeSet<string>>,
21	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
22	id: Cell<usize>,
23}
24impl TypeCollector {
25	pub fn new() -> Self {
26		Self::default()
27	}
28	pub fn collect(&self, item: string) {
29		self.structs.borrow_mut().insert(item);
30	}
31	pub fn next_id(&self) -> usize {
32		let v = self.id.get();
33		self.id.set(v + 1);
34		v
35	}
36	pub fn collect_tuple<T: SolidityTupleType>(&self) -> String {
37		let names = T::names(self);
38		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {
39			return format!("Tuple{}", id);
40		}
41		let id = self.next_id();
42		let mut str = String::new();
43		writeln!(str, "// Anonymous struct").unwrap();
44		writeln!(str, "struct Tuple{} {{", id).unwrap();
45		for (i, name) in names.iter().enumerate() {
46			writeln!(str, "\t{} field_{};", name, i).unwrap();
47		}
48		writeln!(str, "}}").unwrap();
49		self.collect(str);
50		self.anonymous.borrow_mut().insert(names, id);
51		format!("Tuple{}", id)
52	}
53	pub fn finish(self) -> BTreeSet<string> {
54		self.structs.into_inner()
55	}
56}
657
7pub trait SolidityTypeName: 'static {58pub trait SolidityTypeName: 'static {
8	fn solidity_name(writer: &mut impl fmt::Write) -> fmt::Result;59	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
60	fn is_simple() -> bool;
9	fn solidity_default(writer: &mut impl fmt::Write) -> fmt::Result;61	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
10	fn is_void() -> bool {62	fn is_void() -> bool {
11		false63		false
12	}64	}
13}65}
14
15macro_rules! solidity_type_name {66macro_rules! solidity_type_name {
16    ($($ty:ident => $name:literal = $default:literal),* $(,)?) => {67    ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {
17        $(68        $(
18            impl SolidityTypeName for $ty {69            impl SolidityTypeName for $ty {
19                fn solidity_name(writer: &mut impl core::fmt::Write) -> core::fmt::Result {70                fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
20                    write!(writer, $name)71                    write!(writer, $name)
21                }72                }
73				fn is_simple() -> bool {
74					$simple
75				}
22				fn solidity_default(writer: &mut impl core::fmt::Write) -> core::fmt::Result {76				fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {
23					write!(writer, $default)77					write!(writer, $default)
24				}78				}
25            }79            }
28}82}
2983
30solidity_type_name! {84solidity_type_name! {
31	uint8 => "uint8" = "0",85	uint8 => "uint8" true = "0",
32	uint32 => "uint32" = "0",86	uint32 => "uint32" true = "0",
33	uint128 => "uint128" = "0",87	uint128 => "uint128" true = "0",
34	uint256 => "uint256" = "0",88	uint256 => "uint256" true = "0",
35	address => "address" = "0x0000000000000000000000000000000000000000",89	address => "address" true = "0x0000000000000000000000000000000000000000",
36	string => "string memory" = "\"\"",90	string => "string" false = "\"\"",
37	bytes => "bytes memory" = "hex\"\"",91	bytes => "bytes" false = "hex\"\"",
38	bool => "bool" = "false",92	bool => "bool" true = "false",
39}93}
40impl SolidityTypeName for void {94impl SolidityTypeName for void {
41	fn solidity_name(_writer: &mut impl fmt::Write) -> fmt::Result {95	fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
42		Ok(())96		Ok(())
43	}97	}
98	fn is_simple() -> bool {
99		true
100	}
44	fn solidity_default(_writer: &mut impl fmt::Write) -> fmt::Result {101	fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
45		Ok(())102		Ok(())
46	}103	}
47	fn is_void() -> bool {104	fn is_void() -> bool {
48		true105		true
49	}106	}
50}107}
108
109mod sealed {
110	pub trait CanBePlacedInVec {}
111}
112
113impl sealed::CanBePlacedInVec for uint256 {}
114impl sealed::CanBePlacedInVec for string {}
115impl sealed::CanBePlacedInVec for address {}
116
117impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {
118	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
119		T::solidity_name(writer, tc)?;
120		write!(writer, "[]")
121	}
122	fn is_simple() -> bool {
123		false
124	}
125	fn solidity_default(writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
126		write!(writer, "[]")
127	}
128}
129
130pub trait SolidityTupleType {
131	fn names(tc: &TypeCollector) -> Vec<String>;
132	fn len() -> usize;
133}
134
135macro_rules! count {
136    () => (0usize);
137    ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
138}
139
140macro_rules! impl_tuples {
141	($($ident:ident)+) => {
142		impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
143		impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleType for ($($ident,)+) {
144			fn names(tc: &TypeCollector) -> Vec<string> {
145				let mut collected = Vec::with_capacity(Self::len());
146				$({
147					let mut out = string::new();
148					$ident::solidity_name(&mut out, tc).expect("no fmt error");
149					collected.push(out);
150				})*;
151				collected
152			}
153
154			fn len() -> usize {
155				count!($($ident)*)
156			}
157		}
158		impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {
159			fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
160				write!(writer, "{}", tc.collect_tuple::<Self>())
161			}
162			fn is_simple() -> bool {
163				false
164			}
165			fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
166				write!(writer, "{}(", tc.collect_tuple::<Self>())?;
167				$(
168					<$ident>::solidity_default(writer, tc)?;
169				)*
170				write!(writer, ")")
171			}
172		}
173	};
174}
175
176impl_tuples! {A}
177impl_tuples! {A B}
178impl_tuples! {A B C}
179impl_tuples! {A B C D}
180impl_tuples! {A B C D E}
181impl_tuples! {A B C D E F}
182impl_tuples! {A B C D E F G}
183impl_tuples! {A B C D E F G H}
184impl_tuples! {A B C D E F G H I}
185impl_tuples! {A B C D E F G H I J}
51186
52pub trait SolidityArguments {187pub trait SolidityArguments {
53	fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result;188	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
54	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;189	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;
55	fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result;190	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
56	fn is_empty(&self) -> bool {191	fn is_empty(&self) -> bool {
57		self.len() == 0192		self.len() == 0
58	}193	}
63pub struct UnnamedArgument<T>(PhantomData<*const T>);198pub struct UnnamedArgument<T>(PhantomData<*const T>);
64199
65impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {200impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {
66	fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {201	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
67		if !T::is_void() {202		if !T::is_void() {
68			T::solidity_name(writer)203			T::solidity_name(writer, tc)?;
204			if !T::is_simple() {
205				write!(writer, " memory")?;
206			}
207			Ok(())
69		} else {208		} else {
70			Ok(())209			Ok(())
71		}210		}
72	}211	}
73	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {212	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
74		Ok(())213		Ok(())
75	}214	}
76	fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {215	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
77		T::solidity_default(writer)216		T::solidity_default(writer, tc)
78	}217	}
79	fn len(&self) -> usize {218	fn len(&self) -> usize {
80		if T::is_void() {219		if T::is_void() {
94}233}
95234
96impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {235impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {
97	fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {236	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
98		if !T::is_void() {237		if !T::is_void() {
99			T::solidity_name(writer)?;238			T::solidity_name(writer, tc)?;
239			if !T::is_simple() {
240				write!(writer, " memory")?;
241			}
100			write!(writer, " {}", self.0)242			write!(writer, " {}", self.0)
101		} else {243		} else {
102			Ok(())244			Ok(())
105	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {247	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {
106		writeln!(writer, "\t\t{};", self.0)248		writeln!(writer, "\t\t{};", self.0)
107	}249	}
108	fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {250	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
109		T::solidity_default(writer)251		T::solidity_default(writer, tc)
110	}252	}
111	fn len(&self) -> usize {253	fn len(&self) -> usize {
112		if T::is_void() {254		if T::is_void() {
126}268}
127269
128impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {270impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {
129	fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {271	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
130		if !T::is_void() {272		if !T::is_void() {
131			T::solidity_name(writer)?;273			T::solidity_name(writer, tc)?;
132			if self.0 {274			if self.0 {
133				write!(writer, " indexed")?;275				write!(writer, " indexed")?;
134			}276			}
140	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {282	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {
141		writeln!(writer, "\t\t{};", self.1)283		writeln!(writer, "\t\t{};", self.1)
142	}284	}
143	fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {285	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
144		T::solidity_default(writer)286		T::solidity_default(writer, tc)
145	}287	}
146	fn len(&self) -> usize {288	fn len(&self) -> usize {
147		if T::is_void() {289		if T::is_void() {
153}295}
154296
155impl SolidityArguments for () {297impl SolidityArguments for () {
156	fn solidity_name(&self, _writer: &mut impl fmt::Write) -> fmt::Result {298	fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
157		Ok(())299		Ok(())
158	}300	}
159	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {301	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {
160		Ok(())302		Ok(())
161	}303	}
162	fn solidity_default(&self, _writer: &mut impl fmt::Write) -> fmt::Result {304	fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
163		Ok(())305		Ok(())
164	}306	}
165	fn len(&self) -> usize {307	fn len(&self) -> usize {
171impl SolidityArguments for Tuple {313impl SolidityArguments for Tuple {
172	for_tuples!( where #( Tuple: SolidityArguments ),* );314	for_tuples!( where #( Tuple: SolidityArguments ),* );
173315
174	fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {316	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
175		let mut first = true;317		let mut first = true;
176		for_tuples!( #(318		for_tuples!( #(
177            if !Tuple.is_empty() {319            if !Tuple.is_empty() {
178                if !first {320                if !first {
179                    write!(writer, ", ")?;321                    write!(writer, ", ")?;
180                }322                }
181                first = false;323                first = false;
182                Tuple.solidity_name(writer)?;324                Tuple.solidity_name(writer, tc)?;
183            }325            }
184        )* );326        )* );
185		Ok(())327		Ok(())
190        )* );332        )* );
191		Ok(())333		Ok(())
192	}334	}
193	fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {335	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
194		if self.is_empty() {336		if self.is_empty() {
195			Ok(())337			Ok(())
196		} else if self.len() == 1 {338		} else if self.len() == 1 {
197			for_tuples!( #(339			for_tuples!( #(
198				Tuple.solidity_default(writer)?;340				Tuple.solidity_default(writer, tc)?;
199			)* );341			)* );
200			Ok(())342			Ok(())
201		} else {343		} else {
207						write!(writer, ", ")?;349						write!(writer, ", ")?;
208					}350					}
209					first = false;351					first = false;
210					Tuple.solidity_name(writer)?;352					Tuple.solidity_default(writer, tc)?;
211				}353				}
212			)* );354			)* );
213			write!(writer, ")")?;355			write!(writer, ")")?;
223	fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result;365	fn solidity_name(
366		&self,
367		is_impl: bool,
368		writer: &mut impl fmt::Write,
369		tc: &TypeCollector,
370	) -> fmt::Result;
224}371}
225372
229	Mutable,376	Mutable,
230}377}
231pub struct SolidityFunction<A, R> {378pub struct SolidityFunction<A, R> {
379	pub selector: &'static str,
232	pub name: &'static str,380	pub name: &'static str,
233	pub args: A,381	pub args: A,
234	pub result: R,382	pub result: R,
235	pub mutability: SolidityMutability,383	pub mutability: SolidityMutability,
236}384}
237impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {385impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {
238	fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {386	fn solidity_name(
387		&self,
388		is_impl: bool,
389		writer: &mut impl fmt::Write,
390		tc: &TypeCollector,
391	) -> fmt::Result {
392		writeln!(writer, "\t// Selector: {}", self.selector)?;
239		write!(writer, "\tfunction {}(", self.name)?;393		write!(writer, "\tfunction {}(", self.name)?;
240		self.args.solidity_name(writer)?;394		self.args.solidity_name(writer, tc)?;
241		write!(writer, ")")?;395		write!(writer, ")")?;
242		if is_impl {396		if is_impl {
243			write!(writer, " public")?;397			write!(writer, " public")?;
251		}405		}
252		if !self.result.is_empty() {406		if !self.result.is_empty() {
253			write!(writer, " returns (")?;407			write!(writer, " returns (")?;
254			self.result.solidity_name(writer)?;408			self.result.solidity_name(writer, tc)?;
255			write!(writer, ")")?;409			write!(writer, ")")?;
256		}410		}
257		if is_impl {411		if is_impl {
265			}419			}
266			if !self.result.is_empty() {420			if !self.result.is_empty() {
267				write!(writer, "\t\treturn ")?;421				write!(writer, "\t\treturn ")?;
268				self.result.solidity_default(writer)?;422				self.result.solidity_default(writer, tc)?;
269				writeln!(writer, ";")?;423				writeln!(writer, ";")?;
270			}424			}
271			writeln!(writer, "\t}}")?;425			writeln!(writer, "\t}}")?;
283	fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {437	fn solidity_name(
438		&self,
439		is_impl: bool,
440		writer: &mut impl fmt::Write,
441		tc: &TypeCollector,
442	) -> fmt::Result {
284		let mut first = false;443		let mut first = false;
285		for_tuples!( #(444		for_tuples!( #(
286            Tuple.solidity_name(is_impl, writer)?;445            Tuple.solidity_name(is_impl, writer, tc)?;
287        )* );446        )* );
288		Ok(())447		Ok(())
289	}448	}
299	pub fn format(&self, is_impl: bool, out: &mut impl fmt::Write) -> fmt::Result {458	pub fn format(
459		&self,
460		is_impl: bool,
461		out: &mut impl fmt::Write,
462		tc: &TypeCollector,
463	) -> fmt::Result {
300		if is_impl {464		if is_impl {
301			write!(out, "contract ")?;465			write!(out, "contract ")?;
313			}477			}
314		}478		}
315		writeln!(out, " {{")?;479		writeln!(out, " {{")?;
316		self.functions.solidity_name(is_impl, out)?;480		self.functions.solidity_name(is_impl, out, tc)?;
317		writeln!(out, "}}")?;481		writeln!(out, "}}")?;
318		Ok(())482		Ok(())
319	}483	}
328	fn solidity_name(&self, _is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {492	fn solidity_name(
493		&self,
494		_is_impl: bool,
495		writer: &mut impl fmt::Write,
496		tc: &TypeCollector,
497	) -> fmt::Result {
329		write!(writer, "\tevent {}(", self.name)?;498		write!(writer, "\tevent {}(", self.name)?;
330		self.args.solidity_name(writer)?;499		self.args.solidity_name(writer, tc)?;
331		writeln!(writer, ");")500		writeln!(writer, ");")
332	}501	}
333}502}