updated to revised simplified schema

Author: d10r

packages/ethereum-contracts/contracts/interfaces/utils/IUserDefinedMacro.sol

@@ -48,16 +48,16 @@ interface IUserDefinedMacro {
 // Interface for a macro used with the Only712MacroForwarder.
 // Metaphor: a macro is like an api, an action is like an endpoint.
 // Each action can have its own type definition (list of arguments).
-// TODO: for multi-action macros, the getters probably all need to get the encoded message as an argument
 interface IUserDefined712Macro is IUserDefinedMacro {
     // Primary type name (required by the EIP712 type definition), usually rendered prominently by wallets.
     // From a users perspective, it should concisely name the action/intent to be signed.
-    function getPrimaryTypeName() external view returns (string memory);
+    function getPrimaryTypeName(bytes memory params) external view returns (string memory);
 
     // The EIP-712 type definition of the action, required by Only712MacroForwarder.
-    function getMessageTypeDefinition() external view returns (string memory);
+    // Note that the name of this type must be "Action", only its content is free to choose.
+    function getActionTypeDefinition(bytes memory params) external view returns (string memory);
 
     // The struct hash of the action, required by Only712MacroForwarder.
     // This hash must be constructed based on the type definition and the data, according to the EIP-712 standard.
-    function getMessageStructHash(bytes memory message) external view returns (bytes32);
+    function getActionStructHash(bytes memory params) external view returns (bytes32);
 }

packages/ethereum-contracts/contracts/utils/Only712MacroForwarder.sol

@@ -56,34 +56,23 @@ contract Only712MacroForwarder is ForwarderBase, EIP712, NonceManager {
     // STRUCTS, CONSTANTS, IMMUTABLES
 
     // top-level data structure
-    // TODO: is "payload" a good name? Does EIP-712 give a good hint for naming this? Something "primary"?
-    struct Payload {
-        PayloadMeta meta;
-        PayloadMessage message;
-        PayloadSecurity security;
+    struct PrimaryType {
+        ActionType action;
+        SecurityType security;
     }
-    struct PayloadMeta {
-        string domain;
-        string version;
-        //string language;
-        //string disclaimer;
-    }
-    bytes internal constant _TYPEDEF_META = "Meta(string domain,string version)";
-    bytes32 internal constant _TYPEHASH_META = keccak256(_TYPEDEF_META);
-    struct PayloadMessage {
-        string title;
-        //string description;
-        bytes customPayload;
+    struct ActionType {
+        bytes actionParams;
     }
-    // the message typehash is user macro specific
-    struct PayloadSecurity {
+    // the action typehash is macro specific
+    struct SecurityType {
+        string domain;
         string provider;
         uint256 validAfter;
         uint256 validBefore;
         uint256 nonce;
     }
-    bytes internal constant _TYPEDEF_SECURITY = 
-        "Security(string provider,uint256 validAfter,uint256 validBefore,uint256 nonce)";
+    bytes internal constant _TYPEDEF_SECURITY =
+        "Security(string domain,string provider,uint256 validAfter,uint256 validBefore,uint256 nonce)";
 
     bytes32 internal constant _TYPEHASH_SECURITY = keccak256(_TYPEDEF_SECURITY);
 
@@ -119,7 +108,7 @@ contract Only712MacroForwarder is ForwarderBase, EIP712, NonceManager {
         returns (bool)
     {
         // decode the payload
-        Payload memory payload = abi.decode(params, (Payload));
+        PrimaryType memory payload = abi.decode(params, (PrimaryType));
         bytes32 providerRole = keccak256(bytes(payload.security.provider));
         if (!_providerACL.hasRole(providerRole, msg.sender)) {
             revert ProviderNotAuthorized(payload.security.provider, msg.sender);
@@ -134,97 +123,84 @@ contract Only712MacroForwarder is ForwarderBase, EIP712, NonceManager {
             revert OutsideValidityWindow(block.timestamp, payload.security.validBefore, payload.security.validAfter);
         }
 
-        bytes32 digest = _getDigest(m, payload);
+        bytes32 digest = _getDigest(m, params);
 
         // verify the signature - this also works for ERC1271 (contract signatures)
         if (!SignatureChecker.isValidSignatureNow(signer, digest, signature)) {
             revert InvalidSignature();
         }
 
-        // get the operations array from the user macro based on the payload message
+        // get the operations array from the user macro based on the action params
         ISuperfluid.Operation[] memory operations =
-            m.buildBatchOperations(_host, payload.message.customPayload, signer);
+            m.buildBatchOperations(_host, payload.action.actionParams, signer);
 
         // forward the operations
         bool retVal = _forwardBatchCallWithValue(operations, msg.value);
-        // TODO: is customPayload the correct argument here?
-        m.postCheck(_host, payload.message.customPayload, signer);
+        m.postCheck(_host, payload.action.actionParams, signer);
         return retVal;
     }
 
     // TODO: should this exist?
-    function getTypeDefinition(IUserDefined712Macro m) external view returns (string memory) {
-        return _getTypeDefinition(m);
+    function getTypeDefinition(IUserDefined712Macro m, bytes calldata params) external view returns (string memory) {
+        return _getTypeDefinition(m, params);
     }
 
     // TODO: should this exist?
-    function getTypeHash(IUserDefined712Macro m) public view returns (bytes32) {
-        return keccak256(abi.encodePacked(_getTypeDefinition(m)));
+    function getTypeHash(IUserDefined712Macro m, bytes calldata params) public view returns (bytes32) {
+        return keccak256(abi.encodePacked(_getTypeDefinition(m, params)));
     }
 
     // TODO: should this exist?
     function getStructHash(IUserDefined712Macro m, bytes calldata params) external view returns (bytes32) {
-        return _getStructHash(m, abi.decode(params, (Payload)));
+        return _getStructHash(m, params);
     }
 
     function getDigest(IUserDefined712Macro m, bytes calldata params) external view returns (bytes32) {
-        return _getDigest(m, abi.decode(params, (Payload)));
+        return _getDigest(m, params);
     }
 
     // INTERNAL FUNCTIONS
 
-    function _getTypeDefinition(IUserDefined712Macro m) internal view returns (string memory) {
+    function _getTypeDefinition(IUserDefined712Macro m, bytes calldata params) internal view returns (string memory) {
         return string(abi.encodePacked(
-            m.getPrimaryTypeName(),
-            "(Meta meta,Message message,Security security)",
+            m.getPrimaryTypeName(params),
+            "(Action action,Security security)",
             // nested components need to be in alphabetical order
-            m.getMessageTypeDefinition(),
-            _TYPEDEF_META,
+            m.getActionTypeDefinition(params),
             _TYPEDEF_SECURITY
         ));
     }
 
-    function _getStructHash(IUserDefined712Macro m, Payload memory payload) internal view returns (bytes32) {
-        bytes32 metaStructHash = _getMetaStructHash(payload.meta);
-
-        // the message fragment is handled by the user macro.
-        bytes32 messageStructHash = m.getMessageStructHash(
-            abi.encode(payload.message.title, payload.message.customPayload)
-        );
+    function _getStructHash(IUserDefined712Macro m, bytes calldata params) internal view returns (bytes32) {
+        PrimaryType memory payload = abi.decode(params, (PrimaryType));
+        // the action fragment is handled by the user macro.
+        bytes32 actionStructHash = m.getActionStructHash(payload.action.actionParams);
 
         bytes32 securityStructHash = _getSecurityStructHash(payload.security);
 
         // get the typehash
-        bytes32 primaryTypeHash = getTypeHash(m);
+        bytes32 primaryTypeHash = getTypeHash(m, params);
 
         // calculate the struct hash
         bytes32 structHash = keccak256(
             abi.encode(
                 primaryTypeHash,
-                metaStructHash,
-                messageStructHash,
+                actionStructHash,
                 securityStructHash
             )
         );
         return structHash;
     }
 
-    function _getDigest(IUserDefined712Macro m, Payload memory payload) internal view returns (bytes32) {
-        bytes32 structHash = _getStructHash(m, payload);
+    function _getDigest(IUserDefined712Macro m, bytes calldata params) internal view returns (bytes32) {
+        bytes32 structHash = _getStructHash(m, params);
         return _hashTypedDataV4(structHash);
     }
 
-    function _getMetaStructHash(PayloadMeta memory meta) internal pure returns (bytes32) {
-        return keccak256(abi.encode(
-            _TYPEHASH_META,
-            keccak256(bytes(meta.domain)),
-            keccak256(bytes(meta.version))
-        ));
-    }
-
-    function _getSecurityStructHash(PayloadSecurity memory security) internal pure returns (bytes32) {
+    function _getSecurityStructHash(SecurityType memory security) internal pure returns (bytes32) {
         return keccak256(abi.encode(
             _TYPEHASH_SECURITY,
+            keccak256(bytes(security.domain)),
             keccak256(bytes(security.provider)),
             security.validAfter,
             security.validBefore,