`2abdf7d34dd3`

source

crates/evm-coder/src/custom_signature.rs8.8 KiBsource history
1//! # A module for custom signature support.2//!3//! ## Overview4//! This module allows you to create arbitrary signatures for types and functions in compile time.5//!6//! ### Type signatures7//! To create the desired type signature, you need to create your own trait with the `SIGNATURE` constant.8//! Then in the implementation, for the required type, use the macro [`make_signature`]9//! #### Example10//! ```11//! use std::str::from_utf8;12//! use evm_coder::{custom_signature::SignatureUnit, make_signature};13//!14//! // Create trait for our signature15//! trait SoliditySignature {16//!     const SIGNATURE: SignatureUnit;17//!18//!     fn name() -> &'static str {19//!         from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")20//!     }21//! }22//!23//! // Make signatures for some types24//! impl SoliditySignature for u8 {25//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));26//! }27//! impl SoliditySignature for u32 {28//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint32"));29//! }30//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {31//!     const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));32//! }33//! impl<A: SoliditySignature, B: SoliditySignature> SoliditySignature for (A, B) {34//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("(") nameof(A::SIGNATURE) fixed(",") nameof(B::SIGNATURE) fixed(")"));35//! }36//! impl<A: SoliditySignature> SoliditySignature for (A,) {37//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("(") nameof(A::SIGNATURE) fixed(",") shift_left(1) fixed(")"));38//! }39//!40//! assert_eq!(u8::name(), "uint8");41//! assert_eq!(<Vec<u8>>::name(), "uint8[]");42//! assert_eq!(<(u32, u8)>::name(), "(uint32,uint8)");43//! ```44//!45//! ### Function signatures46//! To create a function signature, the macro [`make_signature`] is also used, which accepts47//! settings for the function format [`SignaturePreferences`] and function parameters [`SignatureUnit`]48//! #### Example49//! ```50//! use core::str::from_utf8;51//! use evm_coder::{custom_signature::SignatureUnit, make_signature};52//! // Trait for our signature53//! trait SoliditySignature {54//!     const SIGNATURE: SignatureUnit;55//!56//!     fn name() -> &'static str {57//!         from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")58//!     }59//! }60//!61//! // Make signatures for some types62//! impl SoliditySignature for u8 {63//!     const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));64//! }65//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {66//!     const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));67//! }68//! ```6970/// The maximum length of the signature.71pub const SIGNATURE_SIZE_LIMIT: usize = 256;7273/// Storage for the signature or its elements.74#[derive(Debug)]75pub struct SignatureUnit {76	/// Signature data.77	pub data: [u8; SIGNATURE_SIZE_LIMIT],78	/// The actual size of the data.79	pub len: usize,80}8182impl SignatureUnit {83	/// Create a signature from `&str'.84	pub const fn new(name: &'static str) -> SignatureUnit {85		let mut signature = [0_u8; SIGNATURE_SIZE_LIMIT];86		let name = name.as_bytes();87		let name_len = name.len();88		let mut dst_offset = 0;89		crate::make_signature!(@copy(name, signature, name_len, dst_offset));90		SignatureUnit {91			data: signature,92			len: name_len,93		}94	}95	/// String conversion96	pub fn as_str(&self) -> Option<&str> {97		core::str::from_utf8(&self.data[0..self.len]).ok()98	}99}100101/// ### Macro to create signatures of types and functions.102///103/// Format for creating a type of signature:104/// ```ignore105/// make_signature!(new fixed("uint8")); // Simple type106/// make_signature!(new fixed("(") nameof(u8) fixed(",") nameof(u8) fixed(")")); // Composite type107/// ```108#[macro_export]109macro_rules! make_signature {110	(new $($tt:tt)*) => {111		($crate::custom_signature::SignatureUnit {112			data: {113				let mut out = [0u8; $crate::custom_signature::SIGNATURE_SIZE_LIMIT];114				let mut dst_offset = 0;115				$crate::make_signature!(@data(out, dst_offset); $($tt)*);116				out117			},118			len: {0 + $crate::make_signature!(@size; $($tt)*)},119		})120	};121122	(@size;) => {123		0124	};125	(@size; fixed($expr:expr) $($tt:tt)*) => {126		$expr.len() + $crate::make_signature!(@size; $($tt)*)127	};128	(@size; nameof($expr:expr) $($tt:tt)*) => {129		$expr.len + $crate::make_signature!(@size; $($tt)*)130	};131	(@size; numof($expr:expr) $($tt:tt)*) => {132		{133			let mut out = 0;134			let mut v = $expr;135			if v == 0 {136				out = 1;137			} else {138				while v > 0 {139					out += 1;140					v /= 10;141				}142			}143			out144		} + $crate::make_signature!(@size; $($tt)*)145	};146	(@size; shift_left($expr:expr) $($tt:tt)*) => {147		$crate::make_signature!(@size; $($tt)*) - $expr148	};149150	(@data($dst:ident, $dst_offset:ident);) => {};151	(@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => {152		{153			let data = $expr.as_bytes();154			let data_len = data.len();155			$crate::make_signature!(@copy(data, $dst, data_len, $dst_offset));156		}157		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)158	};159	(@data($dst:ident, $dst_offset:ident); nameof($expr:expr) $($tt:tt)*) => {160		{161			$crate::make_signature!(@copy(&$expr.data, $dst, $expr.len, $dst_offset));162		}163		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)164	};165	(@data($dst:ident, $dst_offset:ident); numof($expr:expr) $($tt:tt)*) => {166		{167			let mut v = $expr;168			let mut need_to_swap = 0;169			if v == 0 {170				$dst[$dst_offset] = b'0';171				$dst_offset += 1;172			} else {173				while v > 0 {174					let n = (v % 10) as u8;175					$dst[$dst_offset] = b'0' + n;176					v /= 10;177					need_to_swap += 1;178					$dst_offset += 1;179				}180			}181			let mut i = 0;182			#[allow(clippy::manual_swap)]183			while i < need_to_swap / 2 {184				let a = $dst_offset - i - 1;185				let b = $dst_offset - need_to_swap + i;186				let v = $dst[a];187				$dst[a] = $dst[b];188				$dst[b] = v;189				i += 1;190			}191		}192		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)193	};194	(@data($dst:ident, $dst_offset:ident); shift_left($expr:expr) $($tt:tt)*) => {195		$dst_offset -= $expr;196		$crate::make_signature!(@data($dst, $dst_offset); $($tt)*)197	};198199	(@copy($src:expr, $dst:expr, $src_len:expr, $dst_offset:ident)) => {200		{201			let mut src_offset = 0;202			let src_len: usize = $src_len;203			while src_offset < src_len {204				$dst[$dst_offset] = $src[src_offset];205				$dst_offset += 1;206				src_offset += 1;207			}208		}209	}210}211212#[cfg(test)]213mod test {214	use core::str::from_utf8;215216	use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit};217218	trait Name {219		const NAME: SignatureUnit;220221		fn name() -> &'static str {222			from_utf8(&Self::NAME.data[..Self::NAME.len]).expect("bad utf-8")223		}224	}225226	impl Name for u8 {227		const NAME: SignatureUnit = make_signature!(new fixed("uint8"));228	}229	impl Name for u32 {230		const NAME: SignatureUnit = make_signature!(new fixed("uint32"));231	}232	impl<T: Name> Name for Vec<T> {233		const NAME: SignatureUnit = make_signature!(new nameof(T::NAME) fixed("[]"));234	}235	impl<A: Name, B: Name> Name for (A, B) {236		const NAME: SignatureUnit =237			make_signature!(new fixed("(") nameof(A::NAME) fixed(",") nameof(B::NAME) fixed(")"));238	}239	impl<A: Name> Name for (A,) {240		const NAME: SignatureUnit =241			make_signature!(new fixed("(") nameof(A::NAME) fixed(",") shift_left(1) fixed(")"));242	}243	impl<A: Name, const SIZE: usize> Name for [A; SIZE] {244		const NAME: SignatureUnit =245			make_signature!(new nameof(A::NAME) fixed("[") numof(SIZE) fixed("]"));246	}247248	struct MaxSize();249	impl Name for MaxSize {250		const NAME: SignatureUnit = SignatureUnit {251			data: [b'!'; SIGNATURE_SIZE_LIMIT],252			len: SIGNATURE_SIZE_LIMIT,253		};254	}255256	#[test]257	fn simple() {258		assert_eq!(u8::name(), "uint8");259		assert_eq!(u32::name(), "uint32");260	}261262	#[test]263	fn vector_of_simple() {264		assert_eq!(<Vec<u8>>::name(), "uint8[]");265		assert_eq!(<Vec<u32>>::name(), "uint32[]");266	}267268	#[test]269	fn vector_of_vector() {270		assert_eq!(<Vec<Vec<u8>>>::name(), "uint8[][]");271	}272273	#[test]274	fn tuple_of_simple() {275		assert_eq!(<(u32, u8)>::name(), "(uint32,uint8)");276	}277278	#[test]279	fn tuple_of_tuple() {280		assert_eq!(281			<((u32, u8), (u8, u32))>::name(),282			"((uint32,uint8),(uint8,uint32))"283		);284	}285286	#[test]287	fn vector_of_tuple() {288		assert_eq!(<Vec<(u32, u8)>>::name(), "(uint32,uint8)[]");289	}290291	#[test]292	fn tuple_of_vector() {293		assert_eq!(<(Vec<u32>, u8)>::name(), "(uint32[],uint8)");294	}295296	#[test]297	fn complex() {298		assert_eq!(299			<(Vec<u32>, (u32, Vec<u8>))>::name(),300			"(uint32[],(uint32,uint8[]))"301		);302	}303304	#[test]305	fn max_size() {306		assert_eq!(<MaxSize>::name(), "!".repeat(SIGNATURE_SIZE_LIMIT));307	}308309	#[test]310	fn shift() {311		assert_eq!(<(u32,)>::name(), "(uint32)");312	}313314	#[test]315	fn num() {316		assert_eq!(<[u8; 0]>::name(), "uint8[0]");317		assert_eq!(<[u8; 1234]>::name(), "uint8[1234]");318		assert_eq!(<[u8; 12345]>::name(), "uint8[12345]");319	}320321	#[test]322	fn over_max_size() {323		let t = trybuild::TestCases::new();324		t.compile_fail("tests/build_failed/custom_signature_over_max_size.rs");325	}326}