Finalizing initial creation of project.

- Bugfixes
- Renamed struct_to_dict to struct_to_message (more accurate to purpose)
- README updated with extra useful info

Author: ajrgrubbs

README.md

@@ -25,7 +25,7 @@ struct Message {
 
 Python representation:
 ```python
-from eip712_structs import EIP712Struct, Address, String, make_domain, struct_to_dict
+from eip712_structs import EIP712Struct, Address, String, make_domain, struct_to_message
 
 class Message(EIP712Struct):
     to = Address()
@@ -37,7 +37,16 @@ msg = Message(to='0xdead...beef', contents='hello world')
 msg.encode_data()  # The struct's data in encoded form
 
 domain = make_domain(name='example')
-msg_body, msg_hash = struct_to_dict(msg, domain)
+msg_body, signable_bytes = struct_to_message(msg, domain)
+
+# msg_body is a standardized dict with keys primaryType, types, domain, and message
+# suitable for converting to JSON for making requests
+
+# `signable bytes` is a deterministic bytes representation of the struct
+# Suitable for hashing or signing
+#   bytes 0-1: b'\x19\x01'
+#   bytes 2-33: domain separator (hash of domain type and data)
+#   bytes 34-65: hash of struct type and data
 ```
 
 #### Dynamic construction
@@ -52,22 +61,29 @@ Message.to = Address()
 setattr(Message, 'from', Address())
 ```
 
-#### Creating Messages and Hashing
+#### The domain separator
 Messages also require a domain struct. A helper method exists for this purpose.
+All values to the `make_domain()`
+function are optional - but at least one must be defined. If omitted, the resulting
+domain struct's definition leaves out the parameter entirely.
+
+The full signature: <br/>
+`make_domain(name: string, version: string, chainId: uint256, verifyingContract: address, salt: bytes32)`
 
 ```python
-from eip712_structs import EIP712Struct, String, make_domain, struct_to_dict
+from eip712_structs import EIP712Struct, String, make_domain, struct_to_message
 
-domain = make_domain(name='my_domain')  # Also accepts kwargs: version, chainId, verifyingContract, salt
+domain = make_domain(name='my_domain')
 
 class Foo(EIP712Struct):
     bar = String()
 
 foo = Foo(bar='baz')
 
-message_dict, message_hash = struct_to_dict(foo, domain)
+message_dict, message_hash = struct_to_message(foo, domain)
 ```
 
+
 ## Member Types
 
 ### Basic types
@@ -111,6 +127,23 @@ Dog.encode_type()     # Dog(string name,string breed)
 Person.encode_type()  # Person(string name,Dog dog)Dog(string name,string breed)
 ```
 
+Instantiating the structs with nested values may be done like:
+
+```python
+# Method one: set it to a struct
+dog = Dog(name='Mochi', breed='Corgi')
+person = Person(name='Ed', dog=dog)
+
+# Method two: set it to a dict - the underlying struct is built for you
+person = Person(
+    name='Ed',
+    dog={
+        'name': 'Mochi',
+        'breed': 'Corgi',
+    }
+)
+```
+
 ### Arrays
 Arrays are also supported for the standard.
 
@@ -123,8 +156,9 @@ array_member = Array(<item_type>[, <optional_length>])
 
 For example:
 ```python
-dynamic_array = Array(X())      # X[] dynamic_array
-static_array  = Array(X(), 10)  # X[10] static_array
+dynamic_array = Array(String())      # String[] dynamic_array
+static_array  = Array(String(), 10)  # String[10] static_array
+struct_array = Array(MyStruct, 10)   # MyStruct[10] - again, don't instantiate structs like the basic types
 ```
 
 ## Development

eip712_structs/__init__.py

@@ -1,6 +1,6 @@
 from eip712_structs.domain_separator import make_domain
-from eip712_structs.struct import EIP712Struct, struct_to_dict, struct_from_dict
+from eip712_structs.struct import EIP712Struct, struct_from_message, struct_to_message
 from eip712_structs.types import Address, Array, Boolean, Bytes, Int, String, Uint
 
 name = 'eip712-structs'
-version = '0.1.2'
+version = '0.1.3'

eip712_structs/struct.py

@@ -120,7 +120,7 @@ def hash_struct(self):
 
         hash_struct => keccak(type_hash || encode_data)
         """
-        return keccak(b''.join([self.type_hash(), self.encode_data()]))
+        return keccak(b''.join([self.type_hash(), self.encode_value()]))
 
     @classmethod
     def get_members(cls) -> List[Tuple[str, EIP712Type]]:
@@ -133,7 +133,7 @@ def get_members(cls) -> List[Tuple[str, EIP712Type]]:
         return members
 
 
-def struct_to_dict(primary_struct: EIP712Struct, domain: EIP712Struct):
+def struct_to_message(primary_struct: EIP712Struct, domain: EIP712Struct):
     """Convert a struct into a dictionary suitable for messaging.
 
     Dictionary is of the form:
@@ -168,12 +168,12 @@ def struct_to_dict(primary_struct: EIP712Struct, domain: EIP712Struct):
         'message': primary_struct.data_dict(),
     }
 
-    typed_data_hash = keccak(b'\x19\x01' + domain.type_hash() + primary_struct.type_hash())
+    typed_data_hash = b'\x19\x01' + domain.type_hash() + primary_struct.type_hash()
 
     return result, typed_data_hash
 
 
-def struct_from_dict(message_dict):
+def struct_from_message(message_dict):
     """Return the EIP712Struct object of the message and domain structs.
 
     :returns: A tuple in the form of: (<primary struct>, <domain struct>)

tests/test_message_json.py

@@ -1,4 +1,4 @@
-from eip712_structs import EIP712Struct, String, make_domain, struct_to_dict, struct_from_dict
+from eip712_structs import EIP712Struct, String, make_domain, struct_to_message, struct_from_message
 
 
 def test_flat_struct_to_message():
@@ -28,11 +28,11 @@ class Foo(EIP712Struct):
         }
     }
 
-    message, _ = struct_to_dict(foo, domain)
+    message, _ = struct_to_message(foo, domain)
     assert message == expected_result
 
     # Now test in reverse...
-    new_struct, domain = struct_from_dict(expected_result)
+    new_struct, domain = struct_from_message(expected_result)
     assert new_struct.type_name == 'Foo'
 
     members_list = new_struct.get_members()
@@ -88,11 +88,11 @@ class Foo(EIP712Struct):
         }
     }
 
-    message, _ = struct_to_dict(foo, domain)
+    message, _ = struct_to_message(foo, domain)
     assert message == expected_result
 
     # And test in reverse...
-    new_struct, new_domain = struct_from_dict(expected_result)
+    new_struct, new_domain = struct_from_message(expected_result)
     assert new_struct.type_name == 'Foo'
 
     members = new_struct.get_members()
@@ -103,3 +103,5 @@ class Foo(EIP712Struct):
     bar_val = new_struct.get_data_value('bar')
     assert bar_val.type_name == 'Bar'
     assert bar_val.get_data_value('s') == 'bar'
+
+    assert foo.hash_struct() == new_struct.hash_struct()