Add array type to parity test

Author: ajrgrubbs

tests/contracts/hash_test_contract.sol

@@ -19,21 +19,33 @@ contract TestContract {
         bytes30 bytes_30;
         bytes dyn_bytes;
         Bar bar;
+        bytes1[] arr;
     }
 
     string constant public BarSig = "Bar(uint256 bar_uint)";
-    string constant public FooSig = "Foo(string s,uint256 u_i,int8 s_i,address a,bool b,bytes30 bytes_30,bytes dyn_bytes,Bar bar)Bar(uint256 bar_uint)";
+    string constant public FooSig = "Foo(string s,uint256 u_i,int8 s_i,address a,bool b,bytes30 bytes_30,bytes dyn_bytes,Bar bar,bytes1[] arr)Bar(uint256 bar_uint)";
 
     bytes32 constant public Bar_TYPEHASH = keccak256(
         abi.encodePacked("Bar(uint256 bar_uint)")
     );
     bytes32 constant public Foo_TYPEHASH = keccak256(
-        abi.encodePacked("Foo(string s,uint256 u_i,int8 s_i,address a,bool b,bytes30 bytes_30,bytes dyn_bytes,Bar bar)Bar(uint256 bar_uint)")
+        abi.encodePacked("Foo(string s,uint256 u_i,int8 s_i,address a,bool b,bytes30 bytes_30,bytes dyn_bytes,Bar bar,bytes1[] arr)Bar(uint256 bar_uint)")
     );
 
     /******************/
     /* Hash Functions */
     /******************/
+    function encodeBytes1Array(bytes1[] memory arr) public pure returns (bytes32) {
+        uint256 len = arr.length;
+        bytes32[] memory padded = new bytes32[](len);
+        for (uint256 i = 0; i < len; i++) {
+            padded[i] = bytes32(arr[i]);
+        }
+        return keccak256(
+            abi.encodePacked(padded)
+        );
+    }
+
     function hashBarStruct(Bar memory bar) public pure returns (bytes32) {
         return keccak256(abi.encode(
             Bar_TYPEHASH,
@@ -51,7 +63,8 @@ contract TestContract {
             foo.b,
             foo.bytes_30,
             keccak256(abi.encodePacked(foo.dyn_bytes)),
-            hashBarStruct(foo.bar)
+            hashBarStruct(foo.bar),
+            encodeBytes1Array(foo.arr)
         ));
     }
 
@@ -71,7 +84,8 @@ contract TestContract {
         bool b,
         bytes30 bytes_30,
         bytes memory dyn_bytes,
-        uint256 bar_uint
+        uint256 bar_uint,
+        bytes1[] memory arr
     ) public pure returns (bytes32) {
         // Construct Foo struct with basic types
         Foo memory foo;
@@ -82,6 +96,7 @@ contract TestContract {
         foo.b = b;
         foo.bytes_30 = bytes_30;
         foo.dyn_bytes = dyn_bytes;
+        foo.arr = arr;
 
         // Construct Bar struct and add it to Foo
         Bar memory bar;

tests/test_chain_parity.py

@@ -4,18 +4,24 @@
 from requests.exceptions import ConnectionError
 from web3 import HTTPProvider, Web3
 
-from eip712_structs import EIP712Struct, String, Uint, Int, Address, Boolean, Bytes
+from eip712_structs import EIP712Struct, String, Uint, Int, Address, Boolean, Bytes, Array
 
 
 @pytest.fixture(scope='module')
 def w3():
+    """Provide a Web3 client to interact with a local chain."""
     client = Web3(HTTPProvider('http://localhost:8545'))
     client.eth.defaultAccount = client.eth.accounts[0]
     return client
 
 
 @pytest.fixture(scope='module')
 def contract(w3):
+    """Deploys the test contract to the local chain, and returns a Web3.py Contract to interact with it.
+
+    Note this expects the contract to be compiled already.
+    This project's docker-compose config pulls a solc container to do this for you.
+    """
     base_path = 'tests/contracts/build/TestContract'
     with open(f'{base_path}.abi', 'r') as f:
         abi = f.read()
@@ -31,6 +37,7 @@ def contract(w3):
 
 
 def skip_this_module():
+    """If we can't reach a local chain, then all tests in this module are skipped."""
     client = Web3(HTTPProvider('http://localhost:8545'))
     try:
         client.eth.accounts
@@ -39,6 +46,7 @@ def skip_this_module():
     return False
 
 
+# Implicitly adds this ``skipif`` mark to the tests below.
 pytestmark = pytest.mark.skipif(skip_this_module(), reason='No accessible test chain.')
 
 
@@ -47,6 +55,7 @@ class Bar(EIP712Struct):
     bar_uint = Uint(256)
 
 
+# TODO Add Array type (w/ appropriate test updates) to this struct.
 class Foo(EIP712Struct):
     s = String()
     u_i = Uint(256)
@@ -56,10 +65,12 @@ class Foo(EIP712Struct):
     bytes_30 = Bytes(30)
     dyn_bytes = Bytes()
     bar = Bar
+    arr = Array(Bytes(1))
 
 
-def get_chain_hash(contract, s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint) -> bytes:
-    result = contract.functions.hashFooStructFromParams(s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint).call()
+def get_chain_hash(contract, s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint, arr) -> bytes:
+    """Uses the contract to create and hash a Foo struct with the given parameters."""
+    result = contract.functions.hashFooStructFromParams(s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint, arr).call()
     return result
 
 
@@ -81,23 +92,35 @@ def test_encoded_types(contract):
     remote_foo_hash = contract.functions.Foo_TYPEHASH().call()
     assert local_foo_hash == remote_foo_hash
 
+    array_type = Array(Bytes(1))
+    bytes_array = [os.urandom(1) for _ in range(5)]
+    local_encoded_array = array_type.encode_value(bytes_array)
+    remote_encoded_array = contract.functions.encodeBytes1Array(bytes_array).call()
+    assert local_encoded_array == remote_encoded_array
+
 
 def test_chain_hash_matches(contract):
+    """Assert that the hashes we derive locally match the hashes derived on-chain."""
+
+    # Initialize basic values
     s = 'some string'
     u_i = 1234
     s_i = -7
     a = Web3.toChecksumAddress(f'0x{os.urandom(20).hex()}')
     b = True
     bytes_30 = os.urandom(30)
     dyn_bytes = os.urandom(50)
+    arr = [os.urandom(1) for _ in range(5)]
 
+    # Initialize a Bar struct, and check it standalone
     bar_uint = 1337
     bar_struct = Bar(bar_uint=bar_uint)
     local_bar_hash = bar_struct.hash_struct()
     remote_bar_hash = contract.functions.hashBarStructFromParams(bar_uint).call()
     assert local_bar_hash == remote_bar_hash
 
-    foo_struct = Foo(s=s, u_i=u_i, s_i=s_i, a=a, b=b, bytes_30=bytes_30, dyn_bytes=dyn_bytes, bar=bar_struct)
+    # Initialize a Foo struct (including the Bar struct above) and check the hashes
+    foo_struct = Foo(s=s, u_i=u_i, s_i=s_i, a=a, b=b, bytes_30=bytes_30, dyn_bytes=dyn_bytes, bar=bar_struct, arr=arr)
     local_foo_hash = foo_struct.hash_struct()
-    remote_foo_hash = get_chain_hash(contract, s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint)
+    remote_foo_hash = get_chain_hash(contract, s, u_i, s_i, a, b, bytes_30, dyn_bytes, bar_uint, arr)
     assert local_foo_hash == remote_foo_hash