@evvm/testnet-contracts 2.3.0 → 3.0.1

package/library/utils/governance/ProposalStructs.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Proposal Data Structures
+ * @author Mate labs
+ * @notice Time-delayed governance proposal structures for safe parameter changes
+ * @dev Three proposal types: AddressTypeProposal, UintTypeProposal, BoolTypeProposal. Standard delay: 1 day (86400s).
+ */
+library ProposalStructs {
+    /**
+     * @notice Time-delayed address change proposal
+     * @dev Used for admin, executor, and contract address updates
+     * @param current Currently active address
+     * @param proposal Proposed new address
+     * @param timeToAccept Timestamp when proposal becomes acceptable
+     */
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @notice Time-delayed numeric value proposal
+     * @dev Used for fees, limits, rates, and thresholds
+     * @param current Currently active value
+     * @param proposal Proposed new value
+     * @param timeToAccept Timestamp when proposal becomes acceptable
+     */
+    struct UintTypeProposal {
+        uint256 current;
+        uint256 proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @notice Time-delayed boolean flag proposal
+     * @dev Used for pause/unpause, enable/disable features. Not suitable for instant emergency stops.
+     * @param flag Current boolean state
+     * @param timeToAccept Timestamp when toggle allowed
+     */
+    struct BoolTypeProposal {
+        bool flag;
+        uint256 timeToAccept;
+    }
+}

package/library/utils/service/CoreExecution.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+/**
+ * @title EVVM Payment Integration for Services
+ * @author Mate labs
+ * @notice Abstract contract providing Core.sol payment processing interface
+ * @dev Four payment types: requestPay (user-to-service with signature), requestDispersePay (batch user-to-service),  makeCaPay (contract-authorized service-to-user), makeDisperseCaPay (batch CA).
+ */
+
+import {ICore, CoreStructs} from "@evvm/testnet-contracts/interfaces/ICore.sol";
+
+abstract contract CoreExecution {
+    /// @notice EVVM core contract reference
+    /// @dev Used for all payment operations
+    ICore internal core;
+
+    /**
+     * @notice Initializes EVVM payment integration
+     * @param _coreAddress Address of Core.sol contract
+     */
+    constructor(address _coreAddress) {
+        core = ICore(_coreAddress);
+    }
+
+    /**
+     * @notice Requests payment from user to service via Evvm.pay with signature validation
+     * @dev Calls core.pay(from, address(this), "", ...). Signature validated by State.validateAndConsumeNonce.
+     * @param from User paying (signer)
+     * @param token Token address
+     * @param amount Token amount
+     * @param priorityFee Executor fee
+     * @param nonce Sequential or async nonce
+     * @param isAsyncExec Nonce type (true=async, false=sync)
+     * @param signature User's ECDSA signature
+     */
+    function requestPay(
+        address from,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        uint256 nonce,
+        bool isAsyncExec,
+        bytes memory signature
+    ) internal virtual {
+        core.pay(
+            from,
+            address(this),
+            "",
+            token,
+            amount,
+            priorityFee,
+            address(this),
+            nonce,
+            isAsyncExec,
+            signature
+        );
+    }
+
+    /**
+     * @notice Requests batch payment from user via Evvm.dispersePay
+     * @dev Signature validated by Core.sol. Total amount must match sum of toData amounts.
+     * @param toData Array of (recipient, amount) pairs
+     * @param token Token address
+     * @param amount Total amount (must match sum)
+     * @param priorityFee Executor fee
+     * @param nonce Sequential or async nonce
+     * @param isAsyncExec Nonce type (true=async, false=sync)
+     * @param signature User's ECDSA signature
+     */
+    function requestDispersePay(
+        CoreStructs.DispersePayMetadata[] memory toData,
+        address token,
+        uint256 amount,
+        uint256 priorityFee,
+        uint256 nonce,
+        bool isAsyncExec,
+        bytes memory signature
+    ) internal virtual {
+        core.dispersePay(
+            address(this),
+            toData,
+            token,
+            amount,
+            priorityFee,
+            address(this),
+            nonce,
+            isAsyncExec,
+            signature
+        );
+    }
+
+    /**
+     * @notice Sends tokens from service to recipient via contract authorization (no signature)
+     * @dev Calls core.caPay(to, token, amount). Service must have sufficient Evvm balance.
+     * @param to Recipient address
+     * @param token Token address
+     * @param amount Token amount
+     */
+    function makeCaPay(
+        address to,
+        address token,
+        uint256 amount
+    ) internal virtual {
+        core.caPay(to, token, amount);
+    }
+
+    /**
+     * @notice Sends tokens to multiple recipients via contract authorization (batch)
+     * @dev Calls evvm.disperseCaPay. Total amount must match sum of toData amounts.
+     * @param toData Array of (recipient, amount) pairs
+     * @param token Token address
+     * @param amount Total amount (must match sum)
+     */
+    function makeDisperseCaPay(
+        CoreStructs.DisperseCaPayMetadata[] memory toData,
+        address token,
+        uint256 amount
+    ) internal virtual {
+        core.disperseCaPay(toData, token, amount);
+    }
+
+    /**
+     * @notice Gets next sequential sync nonce for user
+     * @dev View function returning core.getNextCurrentSyncNonce(user). Auto-increments after each use.
+     * @param user User address to query
+     * @return Next sync nonce for user
+     */
+    function getNextCurrentSyncNonce(
+        address user
+    ) external view returns (uint256) {
+        return core.getNextCurrentSyncNonce(user);
+    }
+
+    /**
+     * @notice Checks if async nonce was consumed
+     * @dev View function returning core.getIfUsedAsyncNonce(user, nonce). Reserved nonces return false until consumed.
+     * @param user User address to query
+     * @param nonce Async nonce to check
+     * @return true if consumed, false if available/reserved
+     */
+    function getIfUsedAsyncNonce(
+        address user,
+        uint256 nonce
+    ) external view returns (bool) {
+        return core.getIfUsedAsyncNonce(user, nonce);
+    }
+
+    /**
+     * @notice Updates Core.sol contract address for governance-controlled upgrades
+     * @dev Should be protected with onlyAdmin and time-delay (ProposalStructs pattern recommended).
+     * @param newCoreAddress New Core.sol contract address
+     */
+    function _changeCoreAddress(address newCoreAddress) internal virtual {
+        core = ICore(newCoreAddress);
+    }
+}

package/library/utils/service/StakingServiceUtils.sol

@@ -2,73 +2,56 @@
 // Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
 pragma solidity ^0.8.0;
 /**
- * @title StakingServiceUtils
- * @author Mate Labs
- * @notice Abstract contract providing staking utilities for EVVM services
- * @dev This contract provides helper functions for services that need to
- * interact with the EVVM Staking contract. Services can stake tokens to:
- *
- * Benefits of Service Staking:
- * - Earn rewards from Fisher (executor) transaction fees
- * - Participate in the EVVM staking ecosystem
- * - Increase service credibility and commitment
- *
- * Staking Flow:
- * 1. Call _makeStakeService with desired amount
- * 2. Contract prepares staking, transfers tokens, and confirms
- * 3. Call _makeUnstakeService when ready to withdraw
- *
- * This contract is designed for use by community-developed services that want
- * to participate in the EVVM staking mechanism.
+ * @title Staking Utilities for EVVM Services
+ * @author Mate labs
+ * @notice Abstract contract for Staking.sol integration enabling services to stake and earn Fisher fees
+ * @dev Three-step staking: prepareServiceStaking → core.caPay(5083 PT * amount) → confirmServiceStaking. Cost: 5083 PT per staking token.
  */
 
 import {IStaking} from "@evvm/testnet-contracts/interfaces/IStaking.sol";
-import {IEvvm} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
+import {ICore} from "@evvm/testnet-contracts/interfaces/ICore.sol";
 
 abstract contract StakingServiceUtils {
-    /// @dev Reference to the Staking contract for staking operations
+    /// @notice Staking contract reference
+    /// @dev Used for all staking operations
     IStaking internal staking;
 
     /**
-     * @notice Initializes the StakingServiceUtils with the Staking contract address
-     * @param stakingAddress Address of the EVVM Staking contract
+     * @notice Initializes staking integration
+     * @param stakingAddress Address of Staking.sol
      */
     constructor(address stakingAddress) {
         staking = IStaking(stakingAddress);
     }
 
     /**
-     * @notice Stakes tokens on behalf of this service contract
-     * @dev Performs the full staking flow:
-     *      1. Prepares staking in the Staking contract
-     *      2. Transfers the required Principal Tokens via EVVM caPay
-     *      3. Confirms the staking operation
-     * @param amountToStake Number of staking units to purchase
+     * @notice Stakes tokens for this service via 3-step atomic process
+     * @dev Calls prepareServiceStaking → core.caPay(PT, cost) → confirmServiceStaking. Requires 5083 PT * amountToStake in service Evvm balance.
+     * @param amountToStake Number of staking tokens to purchase
      */
     function _makeStakeService(uint256 amountToStake) internal {
         staking.prepareServiceStaking(amountToStake);
-        IEvvm(staking.getEvvmAddress()).caPay(
+        ICore(staking.getCoreAddress()).caPay(
             address(staking),
-            IEvvm(staking.getEvvmAddress()).getPrincipalTokenAddress(),
+            ICore(staking.getCoreAddress()).getPrincipalTokenAddress(),
             staking.priceOfStaking() * amountToStake
         );
         staking.confirmServiceStaking();
     }
 
     /**
-     * @notice Unstakes tokens from this service contract
-     * @dev Calls the Staking contract to release staked tokens
-     * @param amountToUnstake Number of staking units to release
+     * @notice Unstakes tokens from this service, burning them and refunding 5083 PT per token
+     * @dev Calls staking.serviceUnstaking(amount). PT refunded to service Evvm balance.
+     * @param amountToUnstake Number of staking tokens to release
      */
     function _makeUnstakeService(uint256 amountToUnstake) internal {
         staking.serviceUnstaking(amountToUnstake);
     }
 
     /**
-     * @notice Updates the Staking contract address
-     * @dev Internal function for governance-controlled Staking address changes.
-     *      Should be protected by time-delayed governance in implementing contracts.
-     * @param newStakingAddress Address of the new Staking contract
+     * @notice Updates Staking.sol contract address for governance-controlled upgrades
+     * @dev Should be protected with onlyAdmin and time-delay. Existing stakes remain in old contract.
+     * @param newStakingAddress New Staking.sol contract address
      */
     function _changeStakingAddress(address newStakingAddress) internal virtual {
         staking = IStaking(newStakingAddress);

package/library/utils/signature/CoreHashUtils.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+import {
+    CoreStructs
+} from "@evvm/testnet-contracts/library/structs/CoreStructs.sol";
+
+/**
+ * @title EVVM Core Hash Utilities
+ * @author Mate labs
+ * @notice Generates deterministic hashes for Core contract payment operations.
+ * @dev Reconstructs data payloads for EIP-191 signature verification within the EVVM ecosystem.
+ */
+library CoreHashUtils {
+
+    /**
+     * @notice Generates hash for single payment operation
+     * @dev Hash: keccak256("pay", to_address, to_identity, token, amount, priorityFee, executor)
+     * @param to_address Direct recipient address
+     * @param to_identity Username for NameService resolution
+     * @param token Token address
+     * @param amount Token amount
+     * @param priorityFee Fee for executor
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForPay(
+        address to_address,
+        string memory to_identity,
+        address token,
+        uint256 amount,
+        uint256 priorityFee
+    ) public pure returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    "pay",
+                    to_address,
+                    to_identity,
+                    token,
+                    amount,
+                    priorityFee
+                )
+            );
+    }
+
+    /**
+     * @notice Generates hash for batch payment operation
+     * @dev Hash: keccak256("dispersePay", toData, token, amount, priorityFee, executor). Single nonce for entire batch.
+     * @param toData Array of recipients and amounts
+     * @param token Token address
+     * @param amount Total amount (must equal sum)
+     * @param priorityFee Fee for executor
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForDispersePay(
+        CoreStructs.DispersePayMetadata[] memory toData,
+        address token,
+        uint256 amount,
+        uint256 priorityFee
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    "dispersePay",
+                    toData,
+                    token,
+                    amount,
+                    priorityFee
+                )
+            );
+    }
+}

package/library/utils/signature/NameServiceHashUtils.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+import {
+    SignatureUtil
+} from "@evvm/testnet-contracts/library/utils/SignatureUtil.sol";
+import {
+    AdvancedStrings
+} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
+
+/**
+ * @title NameServiceHashUtils
+ * @author Mate labs
+ * @notice Hash generation for NameService.sol operations (registration, marketplace, metadata)
+ * @dev Deterministic keccak256 hashes for 10 NameService operations. Used with Core.validateAndConsumeNonce.
+ */
+library NameServiceHashUtils {
+    /**
+     * @notice Generates hash for username pre-registration (commit phase)
+     * @dev Hash: keccak256("preRegistrationUsername", hashUsername). Prevents front-running, valid 30 minutes.
+     * @param hashUsername Keccak256 of (username + lockNumber)
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForPreRegistrationUsername(
+        bytes32 hashUsername
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("preRegistrationUsername", hashUsername));
+    }
+
+    /**
+     * @notice Generates hash for username registration (reveal phase)
+     * @dev Hash: keccak256("registrationUsername", username, lockNumber). Must match pre-reg within 30 minutes. Cost: 100x EVVM reward.
+     * @param username Username being registered
+     * @param lockNumber Random number from pre-registration
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForRegistrationUsername(
+        string memory username,
+        uint256 lockNumber
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(abi.encode("registrationUsername", username, lockNumber));
+    }
+
+    /**
+     * @notice Generates hash for creating marketplace offer
+     * @dev Hash: keccak256("makeOffer", username, amount, expirationDate). Locks PT with 0.5% fee.
+     * @param username Target username
+     * @param amount Principal Tokens offered (pre-fee)
+     * @param expirationDate Offer expiration timestamp
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForMakeOffer(
+        string memory username,
+        uint256 amount,
+        uint256 expirationDate
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(
+                abi.encode("makeOffer", username, amount, expirationDate)
+            );
+    }
+
+    /**
+     * @notice Generates hash for withdrawing marketplace offer
+     * @dev Hash: keccak256("withdrawOffer", username, offerId). Only offer creator can withdraw.
+     * @param username Username with the offer
+     * @param offerId Offer ID to withdraw
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForWithdrawOffer(
+        string memory username,
+        uint256 offerId
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("withdrawOffer", username, offerId));
+    }
+
+    /**
+     * @notice Generates hash for accepting marketplace offer
+     * @dev Hash: keccak256("acceptOffer", username, offerId). Transfers ownership to offerer.
+     * @param username Username being sold
+     * @param offerId Offer ID to accept
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForAcceptOffer(
+        string memory username,
+        uint256 offerId
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("acceptOffer", username, offerId));
+    }
+
+    /**
+     * @notice Generates hash for renewing username
+     * @dev Hash: keccak256("renewUsername", username). Can renew up to 100 years in advance.
+     * @param username Username to renew
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForRenewUsername(
+        string memory username
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("renewUsername", username));
+    }
+
+    /**
+     * @notice Generates hash for adding custom metadata
+     * @dev Hash: keccak256("addCustomMetadata", identity, value). Cost: 10x EVVM reward.
+     * @param identity Username or identity
+     * @param value Metadata value to store
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForAddCustomMetadata(
+        string memory identity,
+        string memory value
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("addCustomMetadata", identity, value));
+    }
+
+    /**
+     * @notice Generates hash for removing custom metadata
+     * @dev Hash: keccak256("removeCustomMetadata", identity, key). Cost: 10x EVVM reward.
+     * @param identity Username or identity
+     * @param key Metadata entry key to remove
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForRemoveCustomMetadata(
+        string memory identity,
+        uint256 key
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("removeCustomMetadata", identity, key));
+    }
+
+    /**
+     * @notice Generates hash for flushing all metadata
+     * @dev Hash: keccak256("flushCustomMetadata", identity). Removes ALL custom metadata entries.
+     * @param identity Username or identity to flush
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForFlushCustomMetadata(
+        string memory identity
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("flushCustomMetadata", identity));
+    }
+
+    /**
+     * @notice Generates hash for flushing username (complete deletion)
+     * @dev Hash: keccak256("flushUsername", username). Irreversible. Deletes all data and makes username available.
+     * @param username Username to delete
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForFlushUsername(
+        string memory username
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("flushUsername", username));
+    }
+}

package/library/utils/signature/P2PSwapHashUtils.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+/**
+ * @title P2P Swap Hash Utilities Library
+ * @author Mate labs
+ * @notice Hash generation for P2PSwap.sol operations (makeOrder, cancelOrder, dispatchOrder)
+ * @dev All hashes validated via Core.sol with async nonces. Three operation types supported.
+ */
+library P2PSwapHashUtils {
+    /**
+     * @notice Generates hash for makeOrder operation
+     * @dev Hash: keccak256("makeOrder", tokenA, tokenB, amountA, amountB). Uses async nonce.
+     * @param tokenA Token offered by seller
+     * @param tokenB Token requested by seller
+     * @param amountA Amount of tokenA offered
+     * @param amountB Amount of tokenB requested
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForMakeOrder(
+        address tokenA,
+        address tokenB,
+        uint256 amountA,
+        uint256 amountB
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(
+                abi.encode("makeOrder", tokenA, tokenB, amountA, amountB)
+            );
+    }
+
+    /**
+     * @notice Generates hash for cancelOrder operation
+     * @dev Hash: keccak256("cancelOrder", tokenA, tokenB, orderId). Only order owner can cancel.
+     * @param tokenA Token A in market pair
+     * @param tokenB Token B in market pair
+     * @param orderId Order ID to cancel
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForCancelOrder(
+        address tokenA,
+        address tokenB,
+        uint256 orderId
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode("cancelOrder", tokenA, tokenB, orderId));
+    }
+
+    /**
+     * @notice Generates hash for dispatchOrder operation
+     * @dev Hash: keccak256("dispatchOrder", tokenA, tokenB, orderId). Used by both fillProportionalFee and fillFixedFee.
+     * @param tokenA Token A in market pair
+     * @param tokenB Token B in market pair
+     * @param orderId Order ID to dispatch
+     * @return Hash for Core.sol validation
+     */
+    function hashDataForDispatchOrder(
+        address tokenA,
+        address tokenB,
+        uint256 orderId
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(abi.encode("dispatchOrder", tokenA, tokenB, orderId));
+    }
+}

package/library/utils/signature/StakingHashUtils.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+/**
+ * @title Staking Hash Utilities
+ * @author Mate labs
+ * @notice Hash functions for staking signature validation (presale/public)
+ * @dev Generates unique hashes with operation-specific prefixes. Used with Core.sol async nonces. Cost: 5083 PT per token.
+ */
+library StakingHashUtils {
+    /**
+     * @notice Hashes presale staking operation parameters for signature validation
+     * @dev Hash: keccak256("presaleStaking", isStaking, amountOfStaking). Used with Core.sol async nonces. Max 2 tokens per user.
+     * @param isStaking true=stake, false=unstake
+     * @param amountOfStaking Number of staking tokens
+     * @return Hash for signature validation
+     */
+    function hashDataForPresaleStake(
+        bool isStaking,
+        uint256 amountOfStaking
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(abi.encode("presaleStaking", isStaking, amountOfStaking));
+    }
+
+    /**
+     * @notice Hashes public staking operation parameters for signature validation
+     * @dev Hash: keccak256("publicStaking", isStaking, amountOfStaking). Used with Core.sol async nonces. Unlimited tokens per user.
+     * @param isStaking true=stake, false=unstake
+     * @param amountOfStaking Number of staking tokens
+     * @return Hash for signature validation
+     */
+    function hashDataForPublicStake(
+        bool isStaking,
+        uint256 amountOfStaking
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(abi.encode("publicStaking", isStaking, amountOfStaking));
+    }
+}

package/library/utils/signature/TreasuryCrossChainHashUtils.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+/**
+ * @title Cross-Chain Treasury Hash Utilities
+ * @author Mate labs
+ * @notice Hash generation for Fisher bridge operations (independent from EVVM)
+ * @dev EIP-191 hashes for cross-chain bridge. Uses own nonce system (NOT Core.sol). Signature validation via SignatureRecover.
+ */
+
+library TreasuryCrossChainHashUtils {
+    /**
+     * @notice Generates hash for Fisher bridge operation
+     * @dev Hash: keccak256("fisherBridge", addressToReceive, tokenAddress, amount, priorityFee). Independent nonce system (NOT Core.sol).
+     * @param addressToReceive Recipient on destination chain
+     * @param tokenAddress Token to bridge (address(0) = ETH)
+     * @param priorityFee Fee for Fisher executor
+     * @param amount Token amount to bridge
+     * @return Hash for ECDSA signature validation
+     */
+    function hashDataForFisherBridge(
+        address addressToReceive,
+        address tokenAddress,
+        uint256 priorityFee,
+        uint256 amount
+    ) public pure returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    "fisherBridge",
+                    addressToReceive,
+                    tokenAddress,
+                    amount,
+                    priorityFee
+                )
+            );
+    }
+            
+}