feat(dyn-abi): clean up and improve performance (#174)

* feat(dyn-abi): clean up and improve performance

* chore: clippy

Cargo.toml

@@ -47,12 +47,13 @@ thiserror = "1.0"
 
 # misc
 arbitrary = "1.3"
-criterion = "0.5"
-derive_arbitrary = "1.3"
 arrayvec = { version = "0.7", default-features = false }
 bytes = { version = "1.4", default-features = false }
+criterion = "0.5"
+derive_arbitrary = "1.3"
 getrandom = "0.2"
 hex = { package = "const-hex", version = ">=1.5", default-features = false, features = ["alloc"] }
+itoa = "1"
 once_cell = "1"
 proptest = "1"
 proptest-derive = "0.3"

crates/dyn-abi/Cargo.toml

@@ -22,6 +22,7 @@ alloy-sol-types = { workspace = true, features = ["eip712-serde"] }
 alloy-primitives.workspace = true
 
 hex.workspace = true
+itoa.workspace = true
 serde.workspace = true
 serde_json = { workspace = true, features = ["alloc"] }
 

crates/dyn-abi/src/eip712/coerce.rs

@@ -1,4 +1,10 @@
-use crate::{no_std_prelude::*, DynAbiError, DynSolType, DynSolValue, Word};
+use crate::{DynAbiError, DynSolType, DynSolValue, Word};
+use alloc::{
+    borrow::ToOwned,
+    boxed::Box,
+    string::{String, ToString},
+    vec::Vec,
+};
 use alloy_primitives::{Address, I256, U256};
 
 /// Coerce a `serde_json::Value` to a `DynSolValue::Address`
@@ -40,7 +46,7 @@ pub(crate) fn bytes(value: &serde_json::Value) -> Result<DynSolValue, DynAbiErro
 pub(crate) fn fixed_bytes(n: usize, value: &serde_json::Value) -> Result<DynSolValue, DynAbiError> {
     if let Some(Ok(buf)) = value.as_str().map(hex::decode) {
         let mut word: Word = Default::default();
-        let min = if buf.len() > n { n } else { buf.len() };
+        let min = n.min(buf.len());
         word[..min].copy_from_slice(&buf[..min]);
         return Ok(DynSolValue::FixedBytes(word, n))
     }

crates/dyn-abi/src/eip712/mod.rs

@@ -7,7 +7,6 @@
 //!
 //! <https://eips.ethereum.org/EIPS/eip-712#specification-of-the-eth_signtypeddata-json-rpc>
 
-/// EIP-712 specific parsing structures.
 pub mod parser;
 
 mod typed_data;

crates/dyn-abi/src/eip712/parser.rs

@@ -1,9 +1,11 @@
+//! EIP-712 specific parsing structures.
+
 use crate::{
     eip712::resolver::{PropertyDef, TypeDef},
-    no_std_prelude::*,
     parser::TypeSpecifier,
     DynAbiError,
 };
+use alloc::vec::Vec;
 
 /// A property is a type and a name. Of the form `type name`. E.g.
 /// `uint256 foo` or `(MyStruct[23],bool) bar`.

crates/dyn-abi/src/eip712/resolver.rs

@@ -1,11 +1,16 @@
 use crate::{
     eip712::typed_data::Eip712Types,
     eip712_parser::EncodeType,
-    no_std_prelude::*,
     parser::{RootType, TypeSpecifier, TypeStem},
     DynAbiError, DynSolType, DynSolValue,
 };
-use alloc::collections::{BTreeMap, BTreeSet};
+use alloc::{
+    borrow::ToOwned,
+    boxed::Box,
+    collections::{BTreeMap, BTreeSet},
+    string::{String, ToString},
+    vec::Vec,
+};
 use alloy_primitives::{keccak256, B256};
 use alloy_sol_types::SolStruct;
 use core::{cmp::Ordering, fmt};
@@ -400,7 +405,7 @@ impl Resolver {
         };
 
         let ty = type_spec.sizes.iter().fold(ty, |acc, item| match item {
-            Some(size) => DynSolType::FixedArray(Box::new(acc), *size),
+            Some(size) => DynSolType::FixedArray(Box::new(acc), size.get()),
             None => DynSolType::Array(Box::new(acc)),
         });
 

crates/dyn-abi/src/eip712/typed_data.rs

@@ -1,10 +1,13 @@
 use crate::{
     eip712::{PropertyDef, Resolver},
-    no_std_prelude::*,
     parser::TypeSpecifier,
     DynAbiError, DynSolType, DynSolValue,
 };
-use alloc::collections::BTreeMap;
+use alloc::{
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec::Vec,
+};
 use alloy_primitives::{keccak256, B256};
 use alloy_sol_types::{Eip712Domain, SolStruct};
 use serde::{Deserialize, Serialize};

crates/dyn-abi/src/error.rs

@@ -1,6 +1,10 @@
-use crate::{no_std_prelude::*, DynSolType};
+use crate::DynSolType;
+use alloc::string::{String, ToString};
 use core::fmt;
 
+/// Dynamic ABI result type.
+pub type DynAbiResult<T, E = DynAbiError> = core::result::Result<T, E>;
+
 /// Error when parsing EIP-712 `encodeType` strings
 ///
 /// <https://eips.ethereum.org/EIPS/eip-712#definition-of-encodetype>
@@ -28,7 +32,15 @@ pub enum DynAbiError {
 }
 
 #[cfg(feature = "std")]
-impl std::error::Error for DynAbiError {}
+impl std::error::Error for DynAbiError {
+    #[inline]
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::HexError(e) => Some(e),
+            _ => None,
+        }
+    }
+}
 
 impl fmt::Display for DynAbiError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

crates/dyn-abi/src/lib.rs

@@ -28,17 +28,8 @@
 #[macro_use]
 extern crate alloc;
 
-mod no_std_prelude {
-    pub(crate) use alloc::{
-        borrow::{Borrow, Cow, ToOwned},
-        boxed::Box,
-        string::{String, ToString},
-        vec::Vec,
-    };
-}
-
 mod error;
-pub use error::DynAbiError;
+pub use error::{DynAbiError, DynAbiResult};
 
 pub use alloy_sol_types::{Decoder, Eip712Domain, Encoder, Error, Result, SolType, Word};