When encoding values, use a suitable default value if a value is None

Author: ajrgrubbs

eip712_structs/__init__.py

@@ -3,4 +3,4 @@
 from eip712_structs.types import Address, Array, Boolean, Bytes, Int, String, Uint
 
 name = 'eip712-structs'
-version = '0.1.5'
+version = '0.1.6'

eip712_structs/struct.py

@@ -27,7 +27,7 @@ class MyStruct(EIP712Struct):
         struct_instance = MyStruct(some_param='some_value')
     """
     def __init__(self, **kwargs):
-        super(EIP712Struct, self).__init__(self.type_name)
+        super(EIP712Struct, self).__init__(self.type_name, None)
         members = self.get_members()
         self.values = dict()
         for name, typ in members:

eip712_structs/types.py

@@ -1,5 +1,5 @@
 import re
-from typing import Union, Type
+from typing import Any, Union, Type
 
 from eth_utils.crypto import keccak
 from eth_utils.conversions import to_int
@@ -8,10 +8,17 @@
 class EIP712Type:
     """The base type for members of a struct.
     """
-    def __init__(self, type_name: str):
+    def __init__(self, type_name: str, none_val: Any):
         self.type_name = type_name
+        self.none_val = none_val
 
     def encode_value(self, value) -> bytes:
+        if value is None:
+            return self._encode_value(self.none_val)
+        else:
+            return self._encode_value(value)
+
+    def _encode_value(self, value) -> bytes:
         """Given a value, verify it and convert into the format required by the spec.
 
         :param value: A correct input value for the implemented type.
@@ -38,19 +45,19 @@ def __init__(self, member_type: Union[EIP712Type, Type[EIP712Type]], fixed_lengt
             type_name = f'{member_type.type_name}[{fixed_length}]'
         self.member_type = member_type
         self.fixed_length = fixed_length
-        super(Array, self).__init__(type_name)
+        super(Array, self).__init__(type_name, [])
 
-    def encode_value(self, value):
+    def _encode_value(self, value):
         encoder = self.member_type
         encoded_values = [encoder.encode_value(v) for v in value]
         return keccak(b''.join(encoded_values))
 
 
 class Address(EIP712Type):
     def __init__(self):
-        super(Address, self).__init__('address')
+        super(Address, self).__init__('address', 0)
 
-    def encode_value(self, value):
+    def _encode_value(self, value):
         # Some smart conversions - need to get an address as an int
         if isinstance(value, bytes):
             v = to_int(value)
@@ -63,9 +70,9 @@ def encode_value(self, value):
 
 class Boolean(EIP712Type):
     def __init__(self):
-        super(Boolean, self).__init__('bool')
+        super(Boolean, self).__init__('bool', False)
 
-    def encode_value(self, value):
+    def _encode_value(self, value):
         if value is False:
             return Uint(256).encode_value(0)
         elif value is True:
@@ -85,9 +92,9 @@ def __init__(self, length: int = 0):
         else:
             raise ValueError(f'Byte length must be between 1 or 32. Got: {length}')
         self.length = length
-        super(Bytes, self).__init__(type_name)
+        super(Bytes, self).__init__(type_name, b'')
 
-    def encode_value(self, value):
+    def _encode_value(self, value):
         if self.length == 0:
             return keccak(value)
         else:
@@ -103,18 +110,18 @@ def __init__(self, length: int):
         if length < 8 or length > 256 or length % 8 != 0:
             raise ValueError(f'Int length must be a multiple of 8, between 8 and 256. Got: {length}')
         self.length = length
-        super(Int, self).__init__(f'int{length}')
+        super(Int, self).__init__(f'int{length}', 0)
 
-    def encode_value(self, value: int):
+    def _encode_value(self, value: int):
         value.to_bytes(self.length // 8, byteorder='big', signed=True)  # For validation
         return value.to_bytes(32, byteorder='big', signed=True)
 
 
 class String(EIP712Type):
     def __init__(self):
-        super(String, self).__init__('string')
+        super(String, self).__init__('string', '')
 
-    def encode_value(self, value):
+    def _encode_value(self, value):
         return keccak(text=value)
 
 
@@ -124,9 +131,9 @@ def __init__(self, length: int):
         if length < 8 or length > 256 or length % 8 != 0:
             raise ValueError(f'Uint length must be a multiple of 8, between 8 and 256. Got: {length}')
         self.length = length
-        super(Uint, self).__init__(f'uint{length}')
+        super(Uint, self).__init__(f'uint{length}', 0)
 
-    def encode_value(self, value: int):
+    def _encode_value(self, value: int):
         value.to_bytes(self.length // 8, byteorder='big', signed=False)  # For validation
         return value.to_bytes(32, byteorder='big', signed=False)
 

tests/test_encode_data.py

@@ -141,3 +141,17 @@ class Foo(EIP712Struct):
     assert sign_bytes[0:2] == start_bytes
     assert sign_bytes[2:34] == exp_domain_bytes
     assert sign_bytes[34:] == exp_struct_bytes
+
+
+def test_none_replacement():
+    class Foo(EIP712Struct):
+        s = String()
+        i = Int(256)
+
+    foo = Foo(**{})
+    encoded_val = foo.encode_value()
+    assert len(encoded_val) == 64
+
+    empty_string_hash = keccak(text='')
+    assert encoded_val[0:32] == empty_string_hash
+    assert encoded_val[32:] == bytes(32)