1#[cfg(not(feature = "std"))]2use alloc::{3 string::String,4 vec::Vec,5 collections::{BTreeSet, BTreeMap},6 format,7};8#[cfg(feature = "std")]9use std::collections::{BTreeSet, BTreeMap};10use core::{11 fmt::{self, Write},12 marker::PhantomData,13 cell::{Cell, RefCell},14};15use impl_trait_for_tuples::impl_for_tuples;16use crate::types::*;1718#[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 v35 }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}5758pub trait SolidityTypeName: 'static {59 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;60 fn is_simple() -> bool;61 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;62 fn is_void() -> bool {63 false64 }65}66macro_rules! solidity_type_name {67 ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {68 $(69 impl SolidityTypeName for $ty {70 fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {71 write!(writer, $name)72 }73 fn is_simple() -> bool {74 $simple75 }76 fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {77 write!(writer, $default)78 }79 }80 )*81 };82}8384solidity_type_name! {85 uint8 => "uint8" true = "0",86 uint32 => "uint32" true = "0",87 uint128 => "uint128" true = "0",88 uint256 => "uint256" true = "0",89 address => "address" true = "0x0000000000000000000000000000000000000000",90 string => "string" false = "\"\"",91 bytes => "bytes" false = "hex\"\"",92 bool => "bool" true = "false",93}94impl SolidityTypeName for void {95 fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {96 Ok(())97 }98 fn is_simple() -> bool {99 true100 }101 fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {102 Ok(())103 }104 fn is_void() -> bool {105 true106 }107}108109mod sealed {110 pub trait CanBePlacedInVec {}111}112113impl sealed::CanBePlacedInVec for uint256 {}114impl sealed::CanBePlacedInVec for string {}115impl sealed::CanBePlacedInVec for address {}116117impl<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 false124 }125 fn solidity_default(writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {126 write!(writer, "[]")127 }128}129130pub trait SolidityTupleType {131 fn names(tc: &TypeCollector) -> Vec<String>;132 fn len() -> usize;133}134135macro_rules! count {136 () => (0usize);137 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));138}139140macro_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 collected152 }153154 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 false164 }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}175176impl_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}186187pub trait SolidityArguments {188 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;189 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;190 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;191 fn is_empty(&self) -> bool {192 self.len() == 0193 }194 fn len(&self) -> usize;195}196197#[derive(Default)]198pub struct UnnamedArgument<T>(PhantomData<*const T>);199200impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {201 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {202 if !T::is_void() {203 T::solidity_name(writer, tc)?;204 if !T::is_simple() {205 write!(writer, " memory")?;206 }207 Ok(())208 } else {209 Ok(())210 }211 }212 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {213 Ok(())214 }215 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {216 T::solidity_default(writer, tc)217 }218 fn len(&self) -> usize {219 if T::is_void() {220 0221 } else {222 1223 }224 }225}226227pub struct NamedArgument<T>(&'static str, PhantomData<*const T>);228229impl<T> NamedArgument<T> {230 pub fn new(name: &'static str) -> Self {231 Self(name, Default::default())232 }233}234235impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {236 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {237 if !T::is_void() {238 T::solidity_name(writer, tc)?;239 if !T::is_simple() {240 write!(writer, " memory")?;241 }242 write!(writer, " {}", self.0)243 } else {244 Ok(())245 }246 }247 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {248 writeln!(writer, "\t\t{};", self.0)249 }250 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {251 T::solidity_default(writer, tc)252 }253 fn len(&self) -> usize {254 if T::is_void() {255 0256 } else {257 1258 }259 }260}261262pub struct SolidityEventArgument<T>(pub bool, &'static str, PhantomData<*const T>);263264impl<T> SolidityEventArgument<T> {265 pub fn new(indexed: bool, name: &'static str) -> Self {266 Self(indexed, name, Default::default())267 }268}269270impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {271 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {272 if !T::is_void() {273 T::solidity_name(writer, tc)?;274 if self.0 {275 write!(writer, " indexed")?;276 }277 write!(writer, " {}", self.1)278 } else {279 Ok(())280 }281 }282 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {283 writeln!(writer, "\t\t{};", self.1)284 }285 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {286 T::solidity_default(writer, tc)287 }288 fn len(&self) -> usize {289 if T::is_void() {290 0291 } else {292 1293 }294 }295}296297impl SolidityArguments for () {298 fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {299 Ok(())300 }301 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {302 Ok(())303 }304 fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {305 Ok(())306 }307 fn len(&self) -> usize {308 0309 }310}311312#[impl_for_tuples(1, 5)]313impl SolidityArguments for Tuple {314 for_tuples!( where #( Tuple: SolidityArguments ),* );315316 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {317 let mut first = true;318 for_tuples!( #(319 if !Tuple.is_empty() {320 if !first {321 write!(writer, ", ")?;322 }323 first = false;324 Tuple.solidity_name(writer, tc)?;325 }326 )* );327 Ok(())328 }329 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {330 for_tuples!( #(331 Tuple.solidity_get(writer)?;332 )* );333 Ok(())334 }335 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {336 if self.is_empty() {337 Ok(())338 } else if self.len() == 1 {339 for_tuples!( #(340 Tuple.solidity_default(writer, tc)?;341 )* );342 Ok(())343 } else {344 write!(writer, "(")?;345 let mut first = true;346 for_tuples!( #(347 if !Tuple.is_empty() {348 if !first {349 write!(writer, ", ")?;350 }351 first = false;352 Tuple.solidity_default(writer, tc)?;353 }354 )* );355 write!(writer, ")")?;356 Ok(())357 }358 }359 fn len(&self) -> usize {360 for_tuples!( #( Tuple.len() )+* )361 }362}363364pub trait SolidityFunctions {365 fn solidity_name(366 &self,367 is_impl: bool,368 writer: &mut impl fmt::Write,369 tc: &TypeCollector,370 ) -> fmt::Result;371}372373pub enum SolidityMutability {374 Pure,375 View,376 Mutable,377}378pub struct SolidityFunction<A, R> {379 pub selector: &'static str,380 pub name: &'static str,381 pub args: A,382 pub result: R,383 pub mutability: SolidityMutability,384}385impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {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)?;393 write!(writer, "\tfunction {}(", self.name)?;394 self.args.solidity_name(writer, tc)?;395 write!(writer, ")")?;396 if is_impl {397 write!(writer, " public")?;398 } else {399 write!(writer, " external")?;400 }401 match &self.mutability {402 SolidityMutability::Pure => write!(writer, " pure")?,403 SolidityMutability::View => write!(writer, " view")?,404 SolidityMutability::Mutable => {}405 }406 if !self.result.is_empty() {407 write!(writer, " returns (")?;408 self.result.solidity_name(writer, tc)?;409 write!(writer, ")")?;410 }411 if is_impl {412 writeln!(writer, " {{")?;413 writeln!(writer, "\t\trequire(false, stub_error);")?;414 self.args.solidity_get(writer)?;415 match &self.mutability {416 SolidityMutability::Pure => {}417 SolidityMutability::View => writeln!(writer, "\t\tdummy;")?,418 SolidityMutability::Mutable => writeln!(writer, "\t\tdummy = 0;")?,419 }420 if !self.result.is_empty() {421 write!(writer, "\t\treturn ")?;422 self.result.solidity_default(writer, tc)?;423 writeln!(writer, ";")?;424 }425 writeln!(writer, "\t}}")?;426 } else {427 writeln!(writer, ";")?;428 }429 Ok(())430 }431}432433#[impl_for_tuples(0, 12)]434impl SolidityFunctions for Tuple {435 for_tuples!( where #( Tuple: SolidityFunctions ),* );436437 fn solidity_name(438 &self,439 is_impl: bool,440 writer: &mut impl fmt::Write,441 tc: &TypeCollector,442 ) -> fmt::Result {443 let mut first = false;444 for_tuples!( #(445 Tuple.solidity_name(is_impl, writer, tc)?;446 )* );447 Ok(())448 }449}450451pub struct SolidityInterface<F: SolidityFunctions> {452 pub name: &'static str,453 pub is: &'static [&'static str],454 pub functions: F,455}456457impl<F: SolidityFunctions> SolidityInterface<F> {458 pub fn format(459 &self,460 is_impl: bool,461 out: &mut impl fmt::Write,462 tc: &TypeCollector,463 ) -> fmt::Result {464 if is_impl {465 write!(out, "contract ")?;466 } else {467 write!(out, "interface ")?;468 }469 write!(out, "{}", self.name)?;470 if !self.is.is_empty() {471 write!(out, " is")?;472 for (i, n) in self.is.iter().enumerate() {473 if i != 0 {474 write!(out, ",")?;475 }476 write!(out, " {}", n)?;477 }478 }479 writeln!(out, " {{")?;480 self.functions.solidity_name(is_impl, out, tc)?;481 writeln!(out, "}}")?;482 Ok(())483 }484}485486pub struct SolidityEvent<A> {487 pub name: &'static str,488 pub args: A,489}490491impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {492 fn solidity_name(493 &self,494 _is_impl: bool,495 writer: &mut impl fmt::Write,496 tc: &TypeCollector,497 ) -> fmt::Result {498 write!(writer, "\tevent {}(", self.name)?;499 self.args.solidity_name(writer, tc)?;500 writeln!(writer, ");")501 }502}