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 name: &'static str,380 pub args: A,381 pub result: R,382 pub mutability: SolidityMutability,383}384impl<A: SolidityArguments, R: SolidityArguments> SolidityFunctions for SolidityFunction<A, R> {385 fn solidity_name(386 &self,387 is_impl: bool,388 writer: &mut impl fmt::Write,389 tc: &TypeCollector,390 ) -> fmt::Result {391 write!(writer, "\tfunction {}(", self.name)?;392 self.args.solidity_name(writer, tc)?;393 write!(writer, ")")?;394 if is_impl {395 write!(writer, " public")?;396 } else {397 write!(writer, " external")?;398 }399 match &self.mutability {400 SolidityMutability::Pure => write!(writer, " pure")?,401 SolidityMutability::View => write!(writer, " view")?,402 SolidityMutability::Mutable => {}403 }404 if !self.result.is_empty() {405 write!(writer, " returns (")?;406 self.result.solidity_name(writer, tc)?;407 write!(writer, ")")?;408 }409 if is_impl {410 writeln!(writer, " {{")?;411 writeln!(writer, "\t\trequire(false, stub_error);")?;412 self.args.solidity_get(writer)?;413 match &self.mutability {414 SolidityMutability::Pure => {}415 SolidityMutability::View => writeln!(writer, "\t\tdummy;")?,416 SolidityMutability::Mutable => writeln!(writer, "\t\tdummy = 0;")?,417 }418 if !self.result.is_empty() {419 write!(writer, "\t\treturn ")?;420 self.result.solidity_default(writer, tc)?;421 writeln!(writer, ";")?;422 }423 writeln!(writer, "\t}}")?;424 } else {425 writeln!(writer, ";")?;426 }427 Ok(())428 }429}430431#[impl_for_tuples(0, 12)]432impl SolidityFunctions for Tuple {433 for_tuples!( where #( Tuple: SolidityFunctions ),* );434435 fn solidity_name(436 &self,437 is_impl: bool,438 writer: &mut impl fmt::Write,439 tc: &TypeCollector,440 ) -> fmt::Result {441 let mut first = false;442 for_tuples!( #(443 Tuple.solidity_name(is_impl, writer, tc)?;444 )* );445 Ok(())446 }447}448449pub struct SolidityInterface<F: SolidityFunctions> {450 pub name: &'static str,451 pub is: &'static [&'static str],452 pub functions: F,453}454455impl<F: SolidityFunctions> SolidityInterface<F> {456 pub fn format(457 &self,458 is_impl: bool,459 out: &mut impl fmt::Write,460 tc: &TypeCollector,461 ) -> fmt::Result {462 if is_impl {463 write!(out, "contract ")?;464 } else {465 write!(out, "interface ")?;466 }467 write!(out, "{}", self.name)?;468 if !self.is.is_empty() {469 write!(out, " is")?;470 for (i, n) in self.is.iter().enumerate() {471 if i != 0 {472 write!(out, ",")?;473 }474 write!(out, " {}", n)?;475 }476 }477 writeln!(out, " {{")?;478 self.functions.solidity_name(is_impl, out, tc)?;479 writeln!(out, "}}")?;480 Ok(())481 }482}483484pub struct SolidityEvent<A> {485 pub name: &'static str,486 pub args: A,487}488489impl<A: SolidityArguments> SolidityFunctions for SolidityEvent<A> {490 fn solidity_name(491 &self,492 _is_impl: bool,493 writer: &mut impl fmt::Write,494 tc: &TypeCollector,495 ) -> fmt::Result {496 write!(writer, "\tevent {}(", self.name)?;497 self.args.solidity_name(writer, tc)?;498 writeln!(writer, ");")499 }500}