Non-Standardized Supporting (rust-ethereum#236)

* Non Standardized `errors`

* Non Standardized `util`

* Non Standardized `param_type`

* Non Standardized `tuple_param`

* More Detail Features

* Non Standardized `param`

* Non Standardized `signature`

* Non Standardized `token`

* Non Standardized `filter`

* Non Standardized `state_mutability`

* Non Standardized `encoder` and `decoder`

* Non Standardized `function`

* Non Standardized `constructor`

* Non Standardized `contract`

* Non Standardized `event_param`

* Non Standardized `operation`

* Fix Compile

* Non Standardized `log`

* Fix Compile

* Non Standardized `event`

* Fix Typo

* Fix Tests

* Fix Typo

* Use `alloc` Globally

* Add `no-default-features` Checks

* Change as Suggest

* Satisfy `cargo-hack`

* Enable `std` by `default`

Author: Xavier Lau

.github/workflows/main.yml

@@ -39,6 +39,11 @@ jobs:
           command: check
           args: --all --all-targets --all-features
 
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --all --all-targets --no-default-features
+
       - uses: actions-rs/cargo@v1
         with:
           command: test
@@ -48,3 +53,8 @@ jobs:
         with:
           command: clippy
           args: --all --all-targets --all-features -- -D warnings
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all --all-targets --no-default-features -- -D warnings

ethabi/Cargo.toml

@@ -13,15 +13,38 @@ description = "Easy to use conversion of ethereum contract calls to bytecode."
 edition = "2018"
 
 [dependencies]
-anyhow = "1"
-hex = "0.4"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-sha3 = "0.9"
-ethereum-types = "0.12.0"
-thiserror = "1"
-uint = "0.9.0"
+anyhow = { version = "1", optional = true }
+hex = { version = "0.4", default-features = false, features = ["alloc"]}
+serde = { version = "1.0", optional =  true, features = ["derive"] }
+serde_json = { version = "1.0", optional = true }
+sha3 = { version = "0.9", default-features = false }
+ethereum-types = { version = "0.12.0", default-features = false }
+thiserror = { version = "1", optional = true }
+uint = { version = "0.9.0", optional = true }
 
 [dev-dependencies]
 hex-literal = "0.3"
 paste = "1"
+
+[features]
+default = [
+	"std",
+	"full-serde",
+]
+std = [
+	"anyhow/std",
+	"hex/std",
+	"sha3/std",
+	"ethereum-types/std",
+	"thiserror",
+	"uint/std",
+]
+
+# To enable custom `Reader`/`Tokenizer` and `serde` features support
+full-serde = [
+	"std",
+	"anyhow",
+	"serde",
+	"serde_json",
+	"uint",
+]

ethabi/src/constructor.rs

@@ -7,11 +7,17 @@
 // except according to those terms.
 
 //! Contract constructor call builder.
-use crate::{encode, Bytes, Error, Param, ParamType, Result, Token};
+
+#[cfg(feature = "full-serde")]
 use serde::{Deserialize, Serialize};
 
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
+use crate::{encode, Bytes, Error, Param, ParamType, Result, Token};
+
 /// Contract constructor specification.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "full-serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Constructor {
 	/// Constructor input.
 	pub inputs: Vec<Param>,

ethabi/src/contract.rs

@@ -6,33 +6,42 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use crate::{errors, operation::Operation, Constructor, Error, Event, Function};
+use alloc::collections::{btree_map::Values, BTreeMap};
+#[cfg(feature = "full-serde")]
+use core::fmt;
+use core::iter::Flatten;
+#[cfg(feature = "full-serde")]
+use std::io;
+
+#[cfg(feature = "full-serde")]
 use serde::{
 	de::{SeqAccess, Visitor},
 	ser::SerializeSeq,
 	Deserialize, Deserializer, Serialize, Serializer,
 };
-use std::{
-	collections::{hash_map::Values, HashMap},
-	fmt, io,
-	iter::Flatten,
-};
+
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
+#[cfg(feature = "full-serde")]
+use crate::operation::Operation;
+use crate::{errors, Constructor, Error, Event, Function};
 
 /// API building calls to contracts ABI.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Contract {
 	/// Contract constructor.
 	pub constructor: Option<Constructor>,
 	/// Contract functions.
-	pub functions: HashMap<String, Vec<Function>>,
+	pub functions: BTreeMap<String, Vec<Function>>,
 	/// Contract events, maps signature to event.
-	pub events: HashMap<String, Vec<Event>>,
+	pub events: BTreeMap<String, Vec<Event>>,
 	/// Contract has receive function.
 	pub receive: bool,
 	/// Contract has fallback function.
 	pub fallback: bool,
 }
 
+#[cfg(feature = "full-serde")]
 impl<'a> Deserialize<'a> for Contract {
 	fn deserialize<D>(deserializer: D) -> Result<Contract, D::Error>
 	where
@@ -42,8 +51,10 @@ impl<'a> Deserialize<'a> for Contract {
 	}
 }
 
+#[cfg(feature = "full-serde")]
 struct ContractVisitor;
 
+#[cfg(feature = "full-serde")]
 impl<'a> Visitor<'a> for ContractVisitor {
 	type Value = Contract;
 
@@ -80,6 +91,7 @@ impl<'a> Visitor<'a> for ContractVisitor {
 	}
 }
 
+#[cfg(feature = "full-serde")]
 impl Serialize for Contract {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
@@ -137,6 +149,7 @@ impl Serialize for Contract {
 
 impl Contract {
 	/// Loads contract from json.
+	#[cfg(feature = "full-serde")]
 	pub fn load<T: io::Read>(reader: T) -> errors::Result<Self> {
 		serde_json::from_reader(reader).map_err(From::from)
 	}
@@ -200,11 +213,11 @@ impl<'a> Iterator for Events<'a> {
 	}
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "full-serde"))]
 #[allow(deprecated)]
 mod test {
 	use crate::{tests::assert_ser_de, Constructor, Contract, Event, EventParam, Function, Param, ParamType};
-	use std::{collections::HashMap, iter::FromIterator};
+	use std::{collections::BTreeMap, iter::FromIterator};
 
 	#[test]
 	fn empty() {
@@ -216,8 +229,8 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::new(),
-				events: HashMap::new(),
+				functions: BTreeMap::new(),
+				events: BTreeMap::new(),
 				receive: false,
 				fallback: false,
 			}
@@ -250,8 +263,8 @@ mod test {
 				constructor: Some(Constructor {
 					inputs: vec![Param { name: "a".to_string(), kind: ParamType::Address, internal_type: None }]
 				}),
-				functions: HashMap::new(),
-				events: HashMap::new(),
+				functions: BTreeMap::new(),
+				events: BTreeMap::new(),
 				receive: false,
 				fallback: false,
 			}
@@ -295,7 +308,7 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::from_iter(vec![
+				functions: BTreeMap::from_iter(vec![
 					(
 						"foo".to_string(),
 						vec![Function {
@@ -325,7 +338,7 @@ mod test {
 						}]
 					)
 				]),
-				events: HashMap::new(),
+				events: BTreeMap::new(),
 				receive: false,
 				fallback: false,
 			}
@@ -369,7 +382,7 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::from_iter(vec![(
+				functions: BTreeMap::from_iter(vec![(
 					"foo".to_string(),
 					vec![
 						Function {
@@ -396,7 +409,7 @@ mod test {
 						}
 					]
 				)]),
-				events: HashMap::new(),
+				events: BTreeMap::new(),
 				receive: false,
 				fallback: false,
 			}
@@ -441,8 +454,8 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::new(),
-				events: HashMap::from_iter(vec![
+				functions: BTreeMap::new(),
+				events: BTreeMap::from_iter(vec![
 					(
 						"foo".to_string(),
 						vec![Event {
@@ -508,8 +521,8 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::new(),
-				events: HashMap::from_iter(vec![(
+				functions: BTreeMap::new(),
+				events: BTreeMap::from_iter(vec![(
 					"foo".to_string(),
 					vec![
 						Event {
@@ -550,8 +563,8 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::new(),
-				events: HashMap::new(),
+				functions: BTreeMap::new(),
+				events: BTreeMap::new(),
 				receive: true,
 				fallback: false,
 			}
@@ -574,8 +587,8 @@ mod test {
 			deserialized,
 			Contract {
 				constructor: None,
-				functions: HashMap::new(),
-				events: HashMap::new(),
+				functions: BTreeMap::new(),
+				events: BTreeMap::new(),
 				receive: false,
 				fallback: true,
 			}

ethabi/src/decoder.rs

@@ -8,6 +8,8 @@
 
 //! ABI decoder.
 
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
 use crate::{Error, ParamType, Token, Word};
 
 #[derive(Debug)]
@@ -217,9 +219,12 @@ fn decode_param(param: &ParamType, data: &[u8], offset: usize) -> Result<DecodeR
 
 #[cfg(test)]
 mod tests {
-	use crate::{decode, ParamType, Token, Uint};
 	use hex_literal::hex;
 
+	#[cfg(not(feature = "std"))]
+	use crate::no_std_prelude::*;
+	use crate::{decode, ParamType, Token, Uint};
+
 	#[test]
 	fn decode_from_empty_byte_slice() {
 		// these can NOT be decoded from empty byte slice

ethabi/src/encoder.rs

@@ -8,6 +8,8 @@
 
 //! ABI encoder.
 
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
 use crate::{util::pad_u32, Bytes, Token, Word};
 
 fn pad_bytes(bytes: &[u8]) -> Vec<Word> {
@@ -175,9 +177,12 @@ fn encode_token(token: &Token) -> Mediate {
 
 #[cfg(test)]
 mod tests {
-	use crate::{encode, util::pad_u32, Token};
 	use hex_literal::hex;
 
+	#[cfg(not(feature = "std"))]
+	use crate::no_std_prelude::*;
+	use crate::{encode, util::pad_u32, Token};
+
 	#[test]
 	fn encode_address() {
 		let address = Token::Address([0x11u8; 20].into());

ethabi/src/errors.rs

@@ -6,39 +6,49 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(feature = "full-serde")]
+use core::num;
+
+#[cfg(feature = "full-serde")]
 use anyhow::anyhow;
-use std::{num, string};
+#[cfg(feature = "std")]
 use thiserror::Error;
 
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
+
 /// Ethabi result type
-pub type Result<T> = std::result::Result<T, Error>;
+pub type Result<T> = core::result::Result<T, Error>;
 
 /// Ethabi errors
-#[derive(Debug, Error)]
+#[cfg_attr(feature = "std", derive(Error))]
+#[derive(Debug)]
 pub enum Error {
 	/// Invalid entity such as a bad function name.
-	#[error("Invalid name: {0}")]
+	#[cfg_attr(feature = "std", error("Invalid name: {0}"))]
 	InvalidName(String),
 	/// Invalid data.
-	#[error("Invalid data")]
+	#[cfg_attr(feature = "std", error("Invalid data"))]
 	InvalidData,
 	/// Serialization error.
+	#[cfg(feature = "full-serde")]
 	#[error("Serialization error: {0}")]
 	SerdeJson(#[from] serde_json::Error),
 	/// Integer parsing error.
+	#[cfg(feature = "full-serde")]
 	#[error("Integer parsing error: {0}")]
 	ParseInt(#[from] num::ParseIntError),
-	/// UTF-8 parsing error.
-	#[error("UTF-8 parsing error: {0}")]
-	Utf8(#[from] string::FromUtf8Error),
 	/// Hex string parsing error.
+	#[cfg(feature = "full-serde")]
 	#[error("Hex parsing error: {0}")]
 	Hex(#[from] hex::FromHexError),
 	/// Other errors.
+	#[cfg(feature = "full-serde")]
 	#[error("{0}")]
 	Other(#[from] anyhow::Error),
 }
 
+#[cfg(feature = "full-serde")]
 impl From<uint::FromDecStrErr> for Error {
 	fn from(err: uint::FromDecStrErr) -> Self {
 		use uint::FromDecStrErr::*;