@evvm/testnet-contracts 2.3.0 → 3.0.1

package/library/Erc191TestBuilder.sol

@@ -11,105 +11,86 @@ pragma solidity ^0.8.0;
  *         https://book.getfoundry.sh/cheatcodes/sign
  */
 
-import {AdvancedStrings} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
+import {
+    CoreStructs
+} from "@evvm/testnet-contracts/library/structs/CoreStructs.sol";
+import {
+    AdvancedStrings
+} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
+import {
+    CoreHashUtils
+} from "@evvm/testnet-contracts/library/utils/signature/CoreHashUtils.sol";
+import {
+    NameServiceHashUtils
+} from "@evvm/testnet-contracts/library/utils/signature/NameServiceHashUtils.sol";
+import {
+    P2PSwapHashUtils
+} from "@evvm/testnet-contracts/library/utils/signature/P2PSwapHashUtils.sol";
+import {
+    StakingHashUtils
+} from "@evvm/testnet-contracts/library/utils/signature/StakingHashUtils.sol";
 
 library Erc191TestBuilder {
     //-----------------------------------------------------------------------------------
     // EVVM
     //-----------------------------------------------------------------------------------
-    
-    /**
-     * @notice Builds the message hash for a pay operation signature
-     * @dev Creates an EIP-191 compatible hash for EVVM pay function
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _receiverAddress Address of the payment receiver (use address(0) if using identity)
-     * @param _receiverIdentity String identity of receiver (used if address is zero)
-     * @param _token Token address being transferred
-     * @param _amount Amount of tokens to transfer
-     * @param _priorityFee Priority fee for transaction processing
-     * @param _nonce Nonce for replay protection
-     * @param _priority_boolean True for async nonce, false for sync nonce
-     * @param _executor Address authorized to execute the transaction
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
+
     function buildMessageSignedForPay(
         uint256 evvmID,
-        address _receiverAddress,
-        string memory _receiverIdentity,
-        address _token,
-        uint256 _amount,
-        uint256 _priorityFee,
-        uint256 _nonce,
-        bool _priority_boolean,
-        address _executor
-    ) internal pure returns (bytes32 messageHash) {
-        string memory messageToSign = string.concat(
-            AdvancedStrings.uintToString(evvmID),
-            ",",
-            "pay",
-            ",",
-            _receiverAddress == address(0)
-                ? _receiverIdentity
-                : AdvancedStrings.addressToString(_receiverAddress),
-            ",",
-            AdvancedStrings.addressToString(_token),
-            ",",
-            AdvancedStrings.uintToString(_amount),
-            ",",
-            AdvancedStrings.uintToString(_priorityFee),
-            ",",
-            AdvancedStrings.uintToString(_nonce),
-            ",",
-            _priority_boolean ? "true" : "false",
-            ",",
-            AdvancedStrings.addressToString(_executor)
-        );
-        messageHash = buildHashForSign(messageToSign);
+        address servicePointer,
+        address to_address,
+        string memory to_identity,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        address senderExecutor,
+        uint256 nonce,
+        bool isAsyncExec
+    ) internal pure returns (bytes32) {
+        return
+            buildHashForSign(
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    CoreHashUtils.hashDataForPay(
+                        to_address,
+                        to_identity,
+                        token,
+                        amount,
+                        priorityFee
+                    ),
+                    senderExecutor,
+                    nonce,
+                    isAsyncExec
+                )
+            );
     }
 
-    /**
-     * @notice Builds the message hash for a disperse pay operation signature
-     * @dev Creates an EIP-191 compatible hash for EVVM dispersePay function
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param hashList Hash of the recipient list for batch payment
-     * @param _token Token address being transferred
-     * @param _amount Total amount of tokens to transfer
-     * @param _priorityFee Priority fee for transaction processing
-     * @param _nonce Nonce for replay protection
-     * @param _priority_boolean True for async nonce, false for sync nonce
-     * @param _executor Address authorized to execute the transaction
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForDispersePay(
         uint256 evvmID,
-        bytes32 hashList,
-        address _token,
-        uint256 _amount,
-        uint256 _priorityFee,
-        uint256 _nonce,
-        bool _priority_boolean,
-        address _executor
-    ) public pure returns (bytes32 messageHash) {
+        address servicePointer,
+        CoreStructs.DispersePayMetadata[] memory toData,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        address senderExecutor,
+        uint256 nonce,
+        bool isAsyncExec
+    ) public pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "dispersePay",
-                    ",",
-                    AdvancedStrings.bytes32ToString(hashList),
-                    ",",
-                    AdvancedStrings.addressToString(_token),
-                    ",",
-                    AdvancedStrings.uintToString(_amount),
-                    ",",
-                    AdvancedStrings.uintToString(_priorityFee),
-                    ",",
-                    AdvancedStrings.uintToString(_nonce),
-                    ",",
-                    _priority_boolean ? "true" : "false",
-                    ",",
-                    AdvancedStrings.addressToString(_executor)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    CoreHashUtils.hashDataForDispersePay(
+                        toData,
+                        token,
+                        amount,
+                        priorityFee
+                    ),
+                    senderExecutor,
+                    nonce,
+                    isAsyncExec
                 )
             );
     }
@@ -118,300 +99,232 @@ library Erc191TestBuilder {
     // MATE NAME SERVICE
     //-----------------------------------------------------------------------------------
 
-    /**
-     * @notice Builds the message hash for username pre-registration
-     * @dev Creates an EIP-191 compatible hash for NameService preRegistrationUsername
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _hashUsername Hash of username + random number for commit-reveal
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForPreRegistrationUsername(
         uint256 evvmID,
-        bytes32 _hashUsername,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        bytes32 hashPreRegisteredUsername,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "preRegistrationUsername",
-                    ",",
-                    AdvancedStrings.bytes32ToString(_hashUsername),
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForPreRegistrationUsername(
+                        hashPreRegisteredUsername
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for username registration
-     * @dev Creates an EIP-191 compatible hash for NameService registrationUsername
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username The username being registered
-     * @param _clowNumber Random number from pre-registration
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForRegistrationUsername(
         uint256 evvmID,
-        string memory _username,
-        uint256 _clowNumber,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        uint256 lockNumber,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "registrationUsername",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_clowNumber),
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForRegistrationUsername(
+                        username,
+                        lockNumber
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for making a username offer
-     * @dev Creates an EIP-191 compatible hash for NameService makeOffer
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Target username for the offer
-     * @param _dateExpire Timestamp when the offer expires
-     * @param _amount Amount being offered in Principal Tokens
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForMakeOffer(
         uint256 evvmID,
-        string memory _username,
-        uint256 _dateExpire,
-        uint256 _amount,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        uint256 amount,
+        uint256 expirationDate,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "makeOffer",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_dateExpire),
-                    ",",
-                    AdvancedStrings.uintToString(_amount),
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForMakeOffer(
+                        username,
+                        amount,
+                        expirationDate
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for withdrawing a username offer
-     * @dev Creates an EIP-191 compatible hash for NameService withdrawOffer
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username the offer was made for
-     * @param _offerId ID of the offer to withdraw
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForWithdrawOffer(
         uint256 evvmID,
-        string memory _username,
-        uint256 _offerId,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        uint256 offerId,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "withdrawOffer",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_offerId),
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForWithdrawOffer(
+                        username,
+                        offerId
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for accepting a username offer
-     * @dev Creates an EIP-191 compatible hash for NameService acceptOffer
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username being sold
-     * @param _offerId ID of the offer to accept
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForAcceptOffer(
         uint256 evvmID,
-        string memory _username,
-        uint256 _offerId,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        uint256 offerId,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "acceptOffer",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_offerId),
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForAcceptOffer(
+                        username,
+                        offerId
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for renewing a username
-     * @dev Creates an EIP-191 compatible hash for NameService renewUsername
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username to renew
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForRenewUsername(
         uint256 evvmID,
-        string memory _username,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "renewUsername",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForRenewUsername(username),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for adding custom metadata
-     * @dev Creates an EIP-191 compatible hash for NameService addCustomMetadata
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username to add metadata to
-     * @param _value Metadata value following schema format
-     * @param _nameServiceNonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForAddCustomMetadata(
         uint256 evvmID,
-        string memory _username,
-        string memory _value,
-        uint256 _nameServiceNonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        string memory value,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "addCustomMetadata",
-                    ",",
-                    _username,
-                    ",",
-                    _value,
-                    ",",
-                    AdvancedStrings.uintToString(_nameServiceNonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForAddCustomMetadata(
+                        username,
+                        value
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for removing custom metadata
-     * @dev Creates an EIP-191 compatible hash for NameService removeCustomMetadata
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username to remove metadata from
-     * @param _key Index of the metadata entry to remove
-     * @param _nonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForRemoveCustomMetadata(
         uint256 evvmID,
-        string memory _username,
-        uint256 _key,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        uint256 key,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "removeCustomMetadata",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_key),
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForRemoveCustomMetadata(
+                        username,
+                        key
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for flushing all custom metadata
-     * @dev Creates an EIP-191 compatible hash for NameService flushCustomMetadata
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username to flush metadata from
-     * @param _nonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForFlushCustomMetadata(
         uint256 evvmID,
-        string memory _username,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "flushCustomMetadata",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForFlushCustomMetadata(
+                        username
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for flushing a username
-     * @dev Creates an EIP-191 compatible hash for NameService flushUsername
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _username Username to completely remove
-     * @param _nonce Nonce for NameService replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForFlushUsername(
         uint256 evvmID,
-        string memory _username,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        string memory username,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "flushUsername",
-                    ",",
-                    _username,
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    NameServiceHashUtils.hashDataForFlushUsername(username),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
@@ -420,99 +333,50 @@ library Erc191TestBuilder {
     // staking functions
     //-----------------------------------------------------------------------------------
 
-    /**
-     * @notice Builds the message hash for public service staking
-     * @dev Creates an EIP-191 compatible hash for Staking publicServiceStaking
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _serviceAddress Address of the service to stake for
-     * @param _isStaking True for staking, false for unstaking
-     * @param _amountOfStaking Amount of staking units
-     * @param _nonce Nonce for replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
-    function buildMessageSignedForPublicServiceStake(
+    function buildMessageSignedForPresaleStaking(
         uint256 evvmID,
-        address _serviceAddress,
-        bool _isStaking,
-        uint256 _amountOfStaking,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        bool isStaking,
+        uint256 amountOfStaking,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "publicServiceStaking",
-                    ",",
-                    AdvancedStrings.addressToString(_serviceAddress),
-                    ",",
-                    _isStaking ? "true" : "false",
-                    ",",
-                    AdvancedStrings.uintToString(_amountOfStaking),
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    StakingHashUtils.hashDataForPresaleStake(
+                        isStaking,
+                        amountOfStaking
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for public staking
-     * @dev Creates an EIP-191 compatible hash for Staking publicStaking
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _isStaking True for staking, false for unstaking
-     * @param _amountOfStaking Amount of staking units
-     * @param _nonce Nonce for replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForPublicStaking(
         uint256 evvmID,
-        bool _isStaking,
-        uint256 _amountOfStaking,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
-        return
-            buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "publicStaking",
-                    ",",
-                    _isStaking ? "true" : "false",
-                    ",",
-                    AdvancedStrings.uintToString(_amountOfStaking),
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
-                )
-            );
-    }
-
-    /**
-     * @notice Builds the message hash for presale staking
-     * @dev Creates an EIP-191 compatible hash for Staking presaleStaking
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _isStaking True for staking, false for unstaking
-     * @param _amountOfStaking Amount of staking units
-     * @param _nonce Nonce for replay protection
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
-    function buildMessageSignedForPresaleStaking(
-        uint256 evvmID,
-        bool _isStaking,
-        uint256 _amountOfStaking,
-        uint256 _nonce
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        bool isStaking,
+        uint256 amountOfStaking,
+        address originExecutor,
+        uint256 nonce
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "presaleStaking",
-                    ",",
-                    _isStaking ? "true" : "false",
-                    ",",
-                    AdvancedStrings.uintToString(_amountOfStaking),
-                    ",",
-                    AdvancedStrings.uintToString(_nonce)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    StakingHashUtils.hashDataForPublicStake(
+                        isStaking,
+                        amountOfStaking
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
@@ -521,111 +385,112 @@ library Erc191TestBuilder {
     // P2PSwap functions
     //-----------------------------------------------------------------------------------
 
-    /**
-     * @notice Builds the message hash for making a P2P swap order
-     * @dev Creates an EIP-191 compatible hash for P2PSwap makeOrder
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _nonce Nonce for replay protection
-     * @param _tokenA Token address being offered
-     * @param _tokenB Token address being requested
-     * @param _amountA Amount of tokenA being offered
-     * @param _amountB Amount of tokenB being requested
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForMakeOrder(
         uint256 evvmID,
-        uint256 _nonce,
-        address _tokenA,
-        address _tokenB,
-        uint256 _amountA,
-        uint256 _amountB
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        address originExecutor,
+        uint256 nonce,
+        address tokenA,
+        address tokenB,
+        uint256 amountA,
+        uint256 amountB
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "makeOrder",
-                    ",",
-                    AdvancedStrings.uintToString(_nonce),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenA),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenB),
-                    ",",
-                    AdvancedStrings.uintToString(_amountA),
-                    ",",
-                    AdvancedStrings.uintToString(_amountB)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    P2PSwapHashUtils.hashDataForMakeOrder(
+                        tokenA,
+                        tokenB,
+                        amountA,
+                        amountB
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for canceling a P2P swap order
-     * @dev Creates an EIP-191 compatible hash for P2PSwap cancelOrder
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _nonce Nonce for replay protection
-     * @param _tokenA Token address that was offered
-     * @param _tokenB Token address that was requested
-     * @param _orderId ID of the order to cancel
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForCancelOrder(
         uint256 evvmID,
-        uint256 _nonce,
-        address _tokenA,
-        address _tokenB,
-        uint256 _orderId
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        address originExecutor,
+        uint256 nonce,
+        address tokenA,
+        address tokenB,
+        uint256 orderId
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "cancelOrder",
-                    ",",
-                    AdvancedStrings.uintToString(_nonce),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenA),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenB),
-                    ",",
-                    AdvancedStrings.uintToString(_orderId)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    P2PSwapHashUtils.hashDataForCancelOrder(
+                        tokenA,
+                        tokenB,
+                        orderId
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
                 )
             );
     }
 
-    /**
-     * @notice Builds the message hash for dispatching (accepting) a P2P swap order
-     * @dev Creates an EIP-191 compatible hash for P2PSwap dispatchOrder
-     * @param evvmID Unique identifier of the EVVM instance
-     * @param _nonce Nonce for replay protection
-     * @param _tokenA Token address that was offered
-     * @param _tokenB Token address that was requested
-     * @param _orderId ID of the order to dispatch
-     * @return messageHash The EIP-191 formatted hash ready for signing
-     */
     function buildMessageSignedForDispatchOrder(
         uint256 evvmID,
-        uint256 _nonce,
-        address _tokenA,
-        address _tokenB,
-        uint256 _orderId
-    ) internal pure returns (bytes32 messageHash) {
+        address servicePointer,
+        address originExecutor,
+        uint256 nonce,
+        address tokenA,
+        address tokenB,
+        uint256 orderId
+    ) internal pure returns (bytes32) {
+        return
+            buildHashForSign(
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    P2PSwapHashUtils.hashDataForDispatchOrder(
+                        tokenA,
+                        tokenB,
+                        orderId
+                    ),
+                    originExecutor,
+                    nonce,
+                    true
+                )
+            );
+    }
+
+    //-----------------------------------------------------------------------------------
+    // nonceConsumer functions
+    //-----------------------------------------------------------------------------------
+
+    function buildMessageSignedForStateTest(
+        uint256 evvmID,
+        address servicePointer,
+        string memory testA,
+        uint256 testB,
+        address testC,
+        bool testD,
+        address originExecutor,
+        uint256 nonce,
+        bool isAsyncExec
+    ) internal pure returns (bytes32) {
         return
             buildHashForSign(
-                string.concat(
-                    AdvancedStrings.uintToString(evvmID),
-                    ",",
-                    "dispatchOrder",
-                    ",",
-                    AdvancedStrings.uintToString(_nonce),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenA),
-                    ",",
-                    AdvancedStrings.addressToString(_tokenB),
-                    ",",
-                    AdvancedStrings.uintToString(_orderId)
+                AdvancedStrings.buildSignaturePayload(
+                    evvmID,
+                    servicePointer,
+                    keccak256(
+                        abi.encode("StateTest", testA, testB, testC, testD)
+                    ),
+                    originExecutor,
+                    nonce,
+                    isAsyncExec
                 )
             );
     }