Optimize LibEIP712

contracts/utils/contracts/src/LibEIP712.sol

@@ -22,15 +22,16 @@ pragma solidity ^0.5.9;
 contract LibEIP712 {
 
     // Hash of the EIP712 Domain Separator Schema
-    bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
+    // keccak256(abi.encodePacked(
-        "EIP712Domain(",
+    //     "EIP712Domain(",
-        "string name,",
+    //     "string name,",
-        "string version,",
+    //     "string version,",
-        "uint256 chainId,",
+    //     "uint256 chainId,",
-        "address verifyingContractAddress",
+    //     "address verifyingContractAddress",
-        ")"
+    //     ")"
-    ));
+    // ))
-
+    bytes32 constant public EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = 0xb1b295f2c1ed6b459ddeb95701466e4e0b385527a6cfa3873ae72a63c08466b6;
+    
     /// @dev Calculates a EIP712 domain separator.
     /// @param name The EIP712 domain name.
     /// @param version The EIP712 domain version.
@@ -46,13 +47,36 @@ contract LibEIP712 {
         pure
         returns (bytes32 result)
     {
-        return keccak256(abi.encodePacked(
+        bytes32 schemaHash = EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH;
-            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
+
-            keccak256(bytes(name)),
+        // Assembly for more efficient computing:
-            keccak256(bytes(version)),
+        // keccak256(abi.encodePacked(
-            chainId,
+        //     EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
-            uint256(verifyingContractAddress)
+        //     keccak256(bytes(name)),
-        ));
+        //     keccak256(bytes(version)),
+        //     chainId,
+        //     uint256(verifyingContractAddress)
+        // ))
+
+        assembly {
+            // Calculate hashes of dynamic data
+            let nameHash := keccak256(add(name, 32), mload(name))
+            let versionHash := keccak256(add(version, 32), mload(version))
+
+            // Load free memory pointer
+            let memPtr := mload(64)
+
+            // Store params in memory
+            mstore(memPtr, schemaHash)
+            mstore(add(memPtr, 32), nameHash)
+            mstore(add(memPtr, 64), versionHash)
+            mstore(add(memPtr, 96), chainId)
+            mstore(add(memPtr, 128), verifyingContractAddress)
+
+            // Compute hash
+            result := keccak256(memPtr, 160)
+        }
+        return result;
     }
 
     /// @dev Calculates EIP712 encoding for a hash struct with a given domain hash.