Add default domain option - constantly providing a domain is annoying

Author: ajrgrubbs

eip712_structs/__init__.py

@@ -4,3 +4,6 @@
 
 name = 'eip712-structs'
 version = '1.0.0'
+
+
+default_domain = None

eip712_structs/struct.py

@@ -4,6 +4,7 @@
 
 from eth_utils.crypto import keccak
 
+import eip712_structs
 from eip712_structs.types import Array, EIP712Type, from_solidity_type
 
 
@@ -137,7 +138,14 @@ def get_members(cls) -> List[Tuple[str, EIP712Type]]:
                    or (isinstance(m[1], type) and issubclass(m[1], EIP712Struct))]
         return members
 
-    def to_message(self, domain: 'EIP712Struct') -> dict:
+    @staticmethod
+    def _assert_domain(domain):
+        result = domain or eip712_structs.default_domain
+        if not result:
+            raise ValueError('Domain must be provided, or eip712_structs.default_domain must be set.')
+        return result
+
+    def to_message(self, domain: 'EIP712Struct' = None) -> dict:
         """Convert a struct into a dictionary suitable for messaging.
 
             Dictionary is of the form:
@@ -150,6 +158,7 @@ def to_message(self, domain: 'EIP712Struct') -> dict:
 
             :returns: This struct + the domain in dict form, structured as specified for EIP712 messages.
             """
+        domain = self._assert_domain(domain)
         structs = {domain, self}
         self._gather_reference_structs(structs)
 
@@ -171,15 +180,16 @@ def to_message(self, domain: 'EIP712Struct') -> dict:
 
         return result
 
-    def signable_bytes(self, domain: 'EIP712Struct') -> bytes:
+    def signable_bytes(self, domain: 'EIP712Struct' = None) -> bytes:
         """Return a ``bytes`` object suitable for signing, as specified for EIP712.
 
         As per the spec, bytes are constructed as follows:
             ``b'\x19\x01' + domain_hash_bytes + struct_hash_bytes``
 
-        :param domain: The domain to include in the hash bytes
+        :param domain: The domain to include in the hash bytes. If None, uses ``eip712_structs.default_domain``
         :return: The bytes object
         """
+        domain = self._assert_domain(domain)
         result = b'\x19\x01' + domain.hash_struct() + self.hash_struct()
         return result
 

tests/test_domain_separator.py

@@ -3,7 +3,17 @@
 import pytest
 from eth_utils.crypto import keccak
 
-from eip712_structs import make_domain
+import eip712_structs
+from eip712_structs import make_domain, EIP712Struct, String
+
+
+@pytest.fixture
+def default_domain_manager():
+    # This fixture can be called to ensure we cleanup our default domain var before/after tests
+    current_value = eip712_structs.default_domain
+    eip712_structs.default_domain = None
+    yield
+    eip712_structs.default_domain = current_value
 
 
 def test_domain_sep_create():
@@ -35,3 +45,37 @@ def test_domain_sep_types():
 
     expected_data = b''.join(encoded_data)
     assert domain_struct.encode_value() == expected_data
+
+
+def test_default_domain(default_domain_manager):
+    assert eip712_structs.default_domain is None
+
+    class Foo(EIP712Struct):
+        s = String()
+    foo = Foo(s='hello world')
+
+    domain = make_domain(name='domain')
+    other_domain = make_domain(name='other domain')
+
+    # When neither methods provide a domain, expect a ValueError
+    with pytest.raises(ValueError, match='Domain must be provided'):
+        foo.to_message()
+    with pytest.raises(ValueError, match='Domain must be provided'):
+        foo.signable_bytes()
+
+    # But we can still provide a domain explicitly
+    explicit_msg = foo.to_message(domain)
+    explicit_bytes = foo.signable_bytes(domain)
+
+    # Setting it lets us forgo providing it
+    eip712_structs.default_domain = domain
+    implicit_msg = foo.to_message()
+    implicit_bytes = foo.signable_bytes()
+
+    # Either method should produce the same result
+    assert implicit_msg == explicit_msg
+    assert implicit_bytes == explicit_bytes
+
+    # Using a different domain should not use any current default domain
+    assert implicit_msg != foo.to_message(other_domain)
+    assert implicit_bytes != foo.signable_bytes(other_domain)