added type-name parser

Author: seunlanlege

Cargo.lock

@@ -17,7 +17,8 @@ failure_derive = "0.1"
 lazy_static = "1.1"
 valico = "2.2"
 linked_hash_set = "0.1.3"
-regex = "1.0"
+toolshed = "0.4"
+lunarity = { git = "https://github.com/paritytech/lunarity" }
 
 [dev-dependencies]
 hex = "0.3"

util/EIP-712/Cargo.toml

@@ -14,18 +14,15 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! EIP712 structs
+//!
+
 use serde_json::{Value};
 use std::collections::HashMap;
-use serde::de;
-use std::fmt;
 use ethereum_types::{U256, H256, Address};
-use regex::Regex;
 
 pub(crate) type MessageTypes = HashMap<String, Vec<FieldType>>;
 
-lazy_static! {
-	static ref RE: Regex = Regex::new(r"[a-zA-z](\[(([1-9][0-9])*)?\]+)?(([1-9][0-9])*)?").unwrap();
-}
 
 #[serde(rename_all = "camelCase")]
 #[serde(deny_unknown_fields)]
@@ -51,37 +48,9 @@ pub struct EIP712 {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub(crate) struct FieldType {
-	#[serde(deserialize_with = "deserialize_field_type_name")]
 	pub name: String,
 	#[serde(rename = "type")]
-	pub type_: String
-}
-
-fn deserialize_field_type_name<'de, D>(deserializer: D) -> Result<String, D::Error>
-	where
-		D: de::Deserializer<'de>,
-{
-	struct FieldTypeNameVisitor;
-
-	impl<'de> de::Visitor<'de> for FieldTypeNameVisitor {
-		type Value = String;
-
-		fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-			formatter.write_str("a string containing json data")
-		}
-
-		fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-			where
-				E: de::Error,
-		{
-			if !RE.is_match(v) {
-				return Err(E::custom(format!("Invalid type definition {}", v)))
-			}
-			Ok(v.to_owned())
-		}
-	}
-
-	deserializer.deserialize_any(FieldTypeNameVisitor)
+	pub type_: String,
 }
 
 #[cfg(test)]

util/EIP-712/src/eip712.rs

@@ -47,7 +47,13 @@ pub enum ErrorKind {
 	ArrayParseError(String),
 	/// schema validation error
 	#[fail(display = "{}", _0)]
-	SchemaValidationError(String)
+	SchemaValidationError(String),
+	/// Unexpected token
+	#[fail(display = "Unexpected token '{}' while parsing typename '{}'", _0, _1)]
+	UnexpectedToken(String, String),
+	/// the user has attempted to define an typed array with a depth > 10
+	#[fail(display = "Maximum depth for nested arrays is 10")]
+	UnsupportedArrayDepth
 }
 
 pub(crate) fn serde_error(expected: &str, field: &str) -> ErrorKind {

util/EIP-712/src/error.rs

@@ -26,56 +26,34 @@ extern crate itertools;
 extern crate failure;
 extern crate valico;
 extern crate linked_hash_set;
-extern crate regex;
+extern crate lunarity;
+extern crate toolshed;
 #[macro_use]
 extern crate failure_derive;
 #[macro_use]
 extern crate serde_derive;
-#[macro_use]
-extern crate lazy_static;
 
 #[cfg(test)]
 extern crate hex;
 
 mod eip712;
 mod error;
 mod schema;
+mod parser;
+use parser::*;
 pub use error::*;
 pub use eip712::*;
 use schema::*;
 
-use ethabi::{encode, Token};
-use ethereum_types::{Address, U256, H256};
+use ethabi::{encode, Token as EthAbiToken};
+use ethereum_types::{Address as EthAddress, U256, H256};
 use keccak_hash::keccak;
 use serde_json::Value;
-use std::collections::HashSet;
 use std::str::FromStr;
 use itertools::Itertools;
 use linked_hash_set::LinkedHashSet;
 use serde_json::to_value;
 
-
-lazy_static! {
-    static ref INT_TYPES: HashSet<&'static str> = vec![
-        "int8", "int16", "int24", "int32", "int40", "int48", "int56", "int64", "int72", "int80",
-        "int88", "int96", "int104", "int112", "int120", "int128", "int136", "int144", "int152", "int160",
-        "int168", "int176", "int184", "int192", "int200", "int208", "int216", "int224", "int232", "int240",
-        "int248", "int256", "uint8", "uint16", "uint24", "uint32", "uint40", "uint48", "uint56",
-        "uint64", "uint72", "uint80", "uint88", "uint96", "uint104", "uint112", "uint120", "uint128",
-        "uint136", "uint144", "uint152", "uint160", "uint168", "uint176", "uint184", "uint192", "uint200",
-        "uint208", "uint216", "uint224", "uint232", "uint240", "uint248", "uint256"
-    ].into_iter().collect();
-
-	static ref BYTES_TYPES: HashSet<&'static str> = vec![
-		"bytes1", "bytes2", "bytes3", "bytes4", "bytes5", "bytes6", "bytes7", "bytes8",
-		"bytes9", "bytes10", "bytes11", "bytes12", "bytes13", "bytes14", "bytes15", "bytes16", "bytes17",
-		"bytes18", "bytes19", "bytes20", "bytes21", "bytes22", "bytes23", "bytes24", "bytes25", "bytes26",
-		"bytes27", "bytes28", "bytes29", "bytes30", "bytes31", "bytes32"
-	].into_iter().collect();
-
-}
-
-
 /// given a type and HashMap<String, Vec<FieldType>>
 /// returns a HashSet of dependent types of the given type
 fn build_dependencies<'a>(message_type: &'a str, message_types: &'a MessageTypes) -> Option<(LinkedHashSet<&'a str>)>
@@ -138,38 +116,43 @@ fn type_hash(message_type: &str, typed_data: &MessageTypes) -> Result<H256> {
 	Ok(keccak(encode_type(message_type, typed_data)?))
 }
 
-fn encode_data(message_type: &str, message_types: &MessageTypes, message: &Value) -> Result<Vec<u8>> {
+fn encode_data(parser: &Parser, message_type: &str, message_types: &MessageTypes, message: &Value) -> Result<Vec<u8>> {
 	let type_hash = (&type_hash(message_type, &message_types)?).to_vec();
-	let mut tokens = vec![Token::FixedBytes(type_hash)];
+	let mut tokens = vec![EthAbiToken::FixedBytes(type_hash)];
+
 	for field in message_types.get(message_type).ok_or_else(|| ErrorKind::NonExistentType)? {
 		let value = &message[&field.name];
-		match &*field.type_ {
-			// Array type e.g uint256[], string[]
-			ty if ty.len() > 1 && ty.rfind(']') == Some(ty.len() - 1) => {
-				let array_type = ty.find('[')
-					.and_then(|index| ty.get(..index))
-					.ok_or_else(|| ErrorKind::ArrayParseError(field.name.clone()))?;
+		let type_ = parser.parse_type(&*field.type_)?;
 
+		match type_ {
+			Type::Array(array_type) => {
 				let mut items = vec![];
 
 				for item in value.as_array().ok_or_else(|| serde_error("array", &field.name))? {
-					// is the array defined in the custom types?
-					if let Some(_) = message_types.get(array_type) {
-						let encoded = encode_data(array_type.into(), &message_types, item)?;
-						items.push(encoded);
-					} else {
-						// it's either a primitive or invalid
-						let token = encode_primitive(array_type.into(), &field.name, item)?;
-						items.push(encode(&[token]));
-					}
+					let nested_type = *array_type.clone();
+					match nested_type {
+						Type::Array(nested_arr) => {
+							let nested_type: String = (*nested_arr).into();
+							let encoded = encode_data(parser, &*nested_type, &message_types, item)?;
+							items.push(encoded);
+						},
+						Type::Custom(ident) => {
+							let encoded = encode_data(parser, &ident, &message_types, item)?;
+							items.push(encoded);
+						}
+						_ => {
+							let token = encode_primitive(nested_type, &field.name, item)?;
+							items.push(encode(&[token]));
+						}
+					};
 				}
-				tokens.push(Token::FixedBytes(keccak(items.concat()).0.to_vec()));
+				tokens.push(EthAbiToken::FixedBytes(keccak(items.concat()).0.to_vec()));
 			}
 			// custom type defined in message types
-			t if message_types.get(t).is_some() => {
-				let encoded = encode_data(&field.type_, &message_types, &value)?;
+			Type::Custom(ref ident) if message_types.get(&*ident).is_some() => {
+				let encoded = encode_data(parser, &ident, &message_types, &value)?;
 				let hash = (&keccak(encoded)).to_vec();
-				tokens.push(Token::FixedBytes(hash));
+				tokens.push(EthAbiToken::FixedBytes(hash));
 			}
 			// ethabi primitive types
 			field_type => {
@@ -181,9 +164,9 @@ fn encode_data(message_type: &str, message_types: &MessageTypes, message: &Value
 	return Ok(encode(&tokens));
 }
 
-fn encode_primitive(field_type: &str, field_name: &str, value: &Value) -> Result<Token> {
+fn encode_primitive(field_type: Type, field_name: &str, value: &Value) -> Result<EthAbiToken> {
 	match field_type {
-		"bytes" => {
+		Type::Bytes(size) if size == 32 => {
 			let string = value.as_str().ok_or_else(|| serde_error("string", field_name))?;
 			if string.len() <= 2 {
 				return Err(ErrorKind::HexParseError(
@@ -193,9 +176,9 @@ fn encode_primitive(field_type: &str, field_name: &str, value: &Value) -> Result
 			let string = string.get(2..).expect("line 188 checks for length; qed");
 			let bytes = H256::from_str(string).map_err(|err| ErrorKind::HexParseError(format!("{}", err)))?;
 			let hash = (&keccak(&bytes)).to_vec();
-			return Ok(Token::FixedBytes(hash));
+			return Ok(EthAbiToken::FixedBytes(hash));
 		}
-		ty if BYTES_TYPES.contains(ty) => {
+		Type::Bytes(size) if size < 32 => {
 			let string = value.as_str().ok_or_else(|| serde_error("string", field_name))?;
 			if string.len() <= 2 {
 				return Err(ErrorKind::HexParseError(
@@ -204,26 +187,25 @@ fn encode_primitive(field_type: &str, field_name: &str, value: &Value) -> Result
 			}
 			let string = string.get(2..).expect("line 200 checks for length; qed");
 			let bytes = H256::from_str(string).map_err(|err| ErrorKind::HexParseError(format!("{}", err)))?;
-			return Ok(Token::FixedBytes(bytes.to_vec()));
+			return Ok(EthAbiToken::FixedBytes(bytes.to_vec()));
 		}
-		"string" => {
+		Type::String => {
 			let value = value.as_str().ok_or_else(|| serde_error("string", field_name))?;
 			let hash = (&keccak(value)).to_vec();
-			return Ok(Token::FixedBytes(hash));
+			return Ok(EthAbiToken::FixedBytes(hash));
 		}
-		"bool" => return Ok(Token::Bool(value.as_bool().ok_or_else(|| serde_error("bool", field_name))?)),
-		"address" => {
+		Type::Bool => return Ok(EthAbiToken::Bool(value.as_bool().ok_or_else(|| serde_error("bool", field_name))?)),
+		Type::Address => {
 			let addr = value.as_str().ok_or_else(|| serde_error("string", field_name))?;
 			if addr.len() != 42 {
 				return Err(ErrorKind::InvalidAddressLength(addr.len()))?;
 			}
 			// we've checked the address length, this is safe
 			let addr = addr.get(2..).unwrap();
-			let address = Address::from_str(addr).map_err(|err| ErrorKind::HexParseError(format!("{}", err)))?;
-			return Ok(Token::Address(address));
+			let address = EthAddress::from_str(addr).map_err(|err| ErrorKind::HexParseError(format!("{}", err)))?;
+			return Ok(EthAbiToken::Address(address));
 		}
-		// (un)signed integers
-		ty if INT_TYPES.contains(ty) => {
+		Type::Uint => {
 			// try to deserialize as a number first, then a string
 			let uint = match (value.as_u64(), value.as_str()) {
 				(Some(number), _) => U256::from(number),
@@ -238,10 +220,10 @@ fn encode_primitive(field_type: &str, field_name: &str, value: &Value) -> Result
 				}
 				_ => return Err(serde_error("int/uint", field_name))?
 			};
-			return Ok(Token::Uint(uint));
+			return Ok(EthAbiToken::Uint(uint));
 		}
 		// the type couldn't be encoded
-		_ => return Err(ErrorKind::UnknownType(field_name.to_owned(), field_type.to_owned()))?
+		_ => return Err(ErrorKind::UnknownType(field_name.to_owned(), "".to_owned()))?
 	}
 }
 
@@ -252,9 +234,10 @@ pub fn hash_data(typed_data: EIP712) -> Result<Vec<u8>> {
 	// EIP-191 compliant
 	let prefix = (b"\x19\x01").to_vec();
 	let domain = to_value(&typed_data.domain).unwrap();
+	let parser = Parser::new();
 	let (domain_hash, data_hash) = (
-		keccak(encode_data("EIP712Domain", &typed_data.types, &domain)?).0,
-		keccak(encode_data(&typed_data.primary_type, &typed_data.types, &typed_data.message)?).0
+		keccak(encode_data(&parser, "EIP712Domain", &typed_data.types, &domain)?).0,
+		keccak(encode_data(&parser, &typed_data.primary_type, &typed_data.types, &typed_data.message)?).0
 	);
 	let concat = [&prefix[..], &domain_hash[..], &data_hash[..]].concat();
 	Ok((&keccak(concat)).to_vec())
@@ -403,7 +386,8 @@ mod tests {
 	#[test]
 	fn test_encode_data() {
 		let typed_data = from_str::<EIP712>(JSON).expect("alas error!");
-		let encoded = encode_data("Mail".into(), &typed_data.types, &typed_data.message).expect("alas error!");
+		let encoded = encode_data(&Parser::new(), "Mail".into(), &typed_data.types, &typed_data.message).expect("alas \
+		error!");
 		assert_eq!(hex::encode(encoded), "a0cedeb2dc280ba39b857546d74f5549c3a1d7bdc2dd96bf881f76108e23dac2fc71e5fa27ff56c350aa531bc129ebdf613b772b6604664f5d8dbe21b85eb0c8cd54f074a4af31b4411ff6a60c9719dbd559c221c8ac3492d9d872b041d703d1b5aadf3154a261abdd9086fc627b61efca26ae5702701d05cd2305f7c52a2fc8")
 	}