Fix basic type handling, add typing tests

Author: ajrgrubbs

eip712_structs/types.py

@@ -19,14 +19,25 @@ def encode_value(self, value) -> bytes:
         """
         pass
 
+    def __eq__(self, other):
+        self_type = getattr(self, 'type_name')
+        other_type = getattr(other, 'type_name')
+
+        return self_type is not None and self_type == other_type
+
+    def __hash__(self):
+        return hash(self.type_name)
+
 
 class Array(EIP712Type):
     def __init__(self, member_type: Union[EIP712Type, Type[EIP712Type]], fixed_length: int = 0):
+        fixed_length = int(fixed_length)
         if fixed_length == 0:
             type_name = f'{member_type.type_name}[]'
         else:
             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)
 
     def encode_value(self, value):
@@ -65,6 +76,7 @@ def encode_value(self, value):
 
 class Bytes(EIP712Type):
     def __init__(self, length: int = 0):
+        length = int(length)
         if length == 0:
             # Special case: Length of 0 means a dynamic bytes type
             type_name = 'bytes'
@@ -87,6 +99,7 @@ def encode_value(self, value):
 
 class Int(EIP712Type):
     def __init__(self, length: int):
+        length = int(length)
         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
@@ -107,6 +120,7 @@ def encode_value(self, value):
 
 class Uint(EIP712Type):
     def __init__(self, length: int):
+        length = int(length)
         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
@@ -145,13 +159,13 @@ def from_solidity_type(solidity_type: str):
 
     base_type = solidity_type_map[type_name]
     if opt_len:
-        type_instance = base_type(opt_len)
+        type_instance = base_type(int(opt_len))
     else:
         type_instance = base_type()
 
     if is_array:
         if array_len:
-            result = Array(type_instance, array_len)
+            result = Array(type_instance, int(array_len))
         else:
             result = Array(type_instance)
         return result

tests/test_types.py

@@ -1,6 +1,7 @@
 import pytest
 
 from eip712_structs import Address, Array, Boolean, Bytes, Int, String, Uint, EIP712Struct
+from eip712_structs.types import from_solidity_type
 
 
 def test_bytes_validation():
@@ -56,3 +57,31 @@ class Foo(EIP712Struct):
 
     assert Array(Foo).type_name == 'Foo[]'
     assert Array(Foo, 10).type_name == 'Foo[10]'
+
+
+def test_length_str_typing():
+    # Ensure that if length is given as a string, it's typecast to int
+    assert Array(String(), '5').fixed_length == 5
+    assert Bytes('10').length == 10
+    assert Int('128').length == 128
+    assert Uint('128').length == 128
+
+
+def test_from_solidity_type():
+    assert from_solidity_type('address') == Address()
+    assert from_solidity_type('bool') == Boolean()
+    assert from_solidity_type('bytes') == Bytes()
+    assert from_solidity_type('bytes32') == Bytes(32)
+    assert from_solidity_type('int128') == Int(128)
+    assert from_solidity_type('string') == String()
+    assert from_solidity_type('uint256') == Uint(256)
+
+    assert from_solidity_type('address[]') == Array(Address())
+    assert from_solidity_type('address[10]') == Array(Address(), 10)
+    assert from_solidity_type('bytes16[32]') == Array(Bytes(16), 32)
+
+    # Sanity check that equivalency is working as expected
+    assert from_solidity_type('bytes32') != Bytes(31)
+    assert from_solidity_type('bytes16[32]') != Array(Bytes(16), 31)
+    assert from_solidity_type('bytes16[32]') != Array(Bytes(), 32)
+    assert from_solidity_type('bytes16[32]') != Array(Bytes(8), 32)