Add type validation to struct value setters/getters

Author: ajrgrubbs

eip712_structs/struct.py

@@ -251,12 +251,40 @@ def from_message(cls, message_dict: dict) -> 'StructTuple':
 
         return result
 
+    @classmethod
+    def _assert_key_is_member(cls, key):
+        member_names = {tup[0] for tup in cls.get_members()}
+        if key not in member_names:
+            raise KeyError(f'"{key}" is not defined for this struct.')
+
+    @classmethod
+    def _assert_property_type(cls, key, value):
+        """Eagerly check for a correct member type"""
+        members = dict(cls.get_members())
+        typ = members[key]
+
+        if isinstance(typ, type) and issubclass(typ, EIP712Struct):
+            # We expect an EIP712Struct instance. Assert that's true, and check the struct signature too.
+            if not isinstance(value, EIP712Struct) or value._encode_type(False) != typ._encode_type(False):
+                raise ValueError(f'Given value is of type {type(value)}, but we expected {typ}')
+        else:
+            # Since it isn't a nested struct, its an EIP712Type
+            try:
+                typ.encode_value(value)
+            except Exception as e:
+                raise ValueError(f'The python type {type(value)} does not appear '
+                                 f'to be supported for data type {typ}.') from e
+
     def __getitem__(self, key):
         """Provide access directly to the underlying value dictionary"""
+        self._assert_key_is_member(key)
         return self.values.__getitem__(key)
 
     def __setitem__(self, key, value):
         """Provide access directly to the underlying value dictionary"""
+        self._assert_key_is_member(key)
+        self._assert_property_type(key, value)
+
         return self.values.__setitem__(key, value)
 
     def __delete__(self, instance):

tests/test_encode_data.py

@@ -205,3 +205,38 @@ class Foo(EIP712Struct):
     foo['b'] = test_bytes_2
 
     assert foo['b'] == test_bytes_2
+
+    with pytest.raises(KeyError):
+        foo['x'] = 'unacceptable'
+
+    # Check behavior when accessing a member that wasn't defined for the struct.
+    with pytest.raises(KeyError):
+        foo['x']
+    # Lets cheat a lil bit for robustness- add an invalid 'x' member to the value dict, and check the error still raises
+    foo.values['x'] = 'test'
+    with pytest.raises(KeyError):
+        foo['x']
+    foo.values.pop('x')
+
+    with pytest.raises(ValueError):
+        foo['s'] = b'unacceptable'
+    with pytest.raises(ValueError):
+        # Bytes do accept strings, but it has to be hex formatted.
+        foo['b'] = 'unacceptable'
+
+    # Test behavior when attempting to set nested structs as values
+    class Bar(EIP712Struct):
+        s = String()
+        f = Foo
+
+    class Baz(EIP712Struct):
+        s = String()
+    baz = Baz(s=test_str)
+
+    bar = Bar(s=test_str)
+    bar['f'] = foo
+    assert bar['f'] == foo
+
+    with pytest.raises(ValueError):
+        # Expects a Foo type, so should throw an error
+        bar['f'] = baz