@evvm/testnet-contracts 1.0.7 → 2.0.0

package/contracts/evvm/Evvm.sol

@@ -20,7 +20,7 @@ pragma solidity ^0.8.0;
    ╚═╝   ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝   ╚═╝   
                                                              
  * @title EVVM (Ethereum Virtual Machine Virtualization) Core Contract
- * @author jistro.eth ariutokintumi.eth
+ * @author Mate labs
  * @notice Core payment processing and token management system for the EVVM ecosystem
  * @dev This contract serves as the central hub for:
  *      - Multi-token payment processing with signature verification

package/contracts/evvm/EvvmLegacy.sol

@@ -61,7 +61,7 @@ pragma solidity ^0.8.0;
    ╚═╝   ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝   ╚═╝   
                                                              
  * @title EVVM (Ethereum Virtual Machine Virtualization) Core Contract
- * @author jistro.eth ariutokintumi.eth
+ * @author Mate labs
  * @notice Core payment processing and token management system for the EVVM ecosystem
  * @dev This contract serves as the central hub for:
  *      - Multi-token payment processing with signature verification

package/contracts/evvm/lib/EvvmStorage.sol

@@ -7,7 +7,7 @@ import {EvvmStructs} from "./EvvmStructs.sol";
 
 /**
  * @title EvvmStorage
- * @author jistro.eth
+ * @author Mate labs
  * @dev Storage layout contract for EVVM proxy pattern implementation.
  *      This contract inherits all structures from EvvmStructs and
  *      defines the storage layout that will be used by the proxy pattern.

package/contracts/nameService/NameService.sol

@@ -27,7 +27,7 @@ pragma solidity ^0.8.0;
    ╚═╝   ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝   ╚═╝   
  *
  * @title EVVM Name Service Contract
- * @author jistro.eth ariutokintumi.eth
+ * @author Mate labs
  * @notice This contract manages username registration and domain name services for the EVVM ecosystem
  * @dev Provides a comprehensive domain name system with features including:
  *

package/contracts/staking/Estimator.sol

@@ -12,7 +12,7 @@ MM        .M `88888P'   dP   dP dP  dP  dP `88888P8   dP   `88888P' dP
 MMMMMMMMMMMM                                                                 
                                                                             
  * @title Staking Mate contract for Roll A Mate Protocol 
- * @author jistro.eth ariutokintumi.eth
+ * @author Mate labs
  */
 
 import {Staking} from "@evvm/testnet-contracts/contracts/staking/Staking.sol";

package/contracts/staking/Staking.sol

@@ -24,7 +24,7 @@ pragma solidity ^0.8.0;
    ██║   ███████╗███████║   ██║   ██║ ╚████║███████╗   ██║   
    ╚═╝   ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝   ╚═╝   
  * @title Staking Mate contract
- * @author jistro.eth ariutokintumi.eth
+ * @author Mate labs
  * @notice This contract manages the staking mechanism for the EVVM ecosystem
  * @dev Handles presale staking, public staking, and service staking with time locks and signature verification
  *
@@ -109,6 +109,32 @@ contract Staking {
         uint256 timeToAccept;
     }
 
+    /**
+     * @dev Struct to store service staking metadata during the staking process
+     * @param service Address of the service or contract account
+     * @param timestamp Timestamp when the prepareServiceStaking was called
+     * @param amountOfStaking Amount of staking tokens to be staked
+     * @param amountServiceBeforeStaking Service's Principal Token balance before staking
+     * @param amountStakingBeforeStaking Staking contract's Principal Token balance before staking
+     */
+    struct ServiceStakingMetadata {
+        address service;
+        uint256 timestamp;
+        uint256 amountOfStaking;
+        uint256 amountServiceBeforeStaking;
+        uint256 amountStakingBeforeStaking;
+    }
+
+    /**
+     * @dev Struct to encapsulate account metadata for staking operations
+     * @param Address Address of the account
+     * @param IsAService Boolean indicating if the account is a smart contract (service) account
+     */
+    struct AccountMetadata {
+        address Address;
+        bool IsAService;
+    }
+
     /// @dev Address of the EVVM core contract
     address private EVVM_ADDRESS;
 
@@ -119,6 +145,10 @@ contract Staking {
     /// @dev Price of one staking main token (5083 main token = 1 staking)
     uint256 private constant PRICE_OF_STAKING = 5083 * (10 ** 18);
 
+    /// @dev Address representing the principal Principal Token
+    address private constant PRINCIPAL_TOKEN_ADDRESS =
+        0x0000000000000000000000000000000000000001;
+
     /// @dev Admin address management with proposal system
     AddressTypeProposal private admin;
     /// @dev Golden Fisher address management with proposal system
@@ -133,10 +163,8 @@ contract Staking {
     BoolTypeProposal private allowPresaleStaking;
     /// @dev Flag to enable/disable public staking
     BoolTypeProposal private allowPublicStaking;
-
-    /// @dev Address representing the principal Principal Token
-    address private constant PRINCIPAL_TOKEN_ADDRESS =
-        0x0000000000000000000000000000000000000001;
+    /// @dev Variable to store service staking metadata
+    ServiceStakingMetadata private serviceStakingData;
 
     /// @dev One-time setup breaker for estimator and EVVM addresses
     bytes1 private breakerSetupEstimatorAndEvvm;
@@ -150,13 +178,28 @@ contract Staking {
     /// @dev Mapping to store complete staking history for each user
     mapping(address => HistoryMetadata[]) private userHistory;
 
-    /// @dev Modifier to restrict access to admin functions
+    /// @dev Modifier to verify access to admin functions
     modifier onlyOwner() {
         if (msg.sender != admin.actual) revert ErrorsLib.SenderIsNotAdmin();
 
         _;
     }
 
+    /// @dev Modifier to verify access to a contract or service account
+    modifier onlyCA() {
+        uint256 size;
+        address callerAddress = msg.sender;
+
+        assembly {
+            /// @dev check the size of the opcode of the address
+            size := extcodesize(callerAddress)
+        }
+
+        if (size == 0) revert ErrorsLib.AddressIsNotAService();
+
+        _;
+    }
+
     /**
      * @notice Contract constructor
      * @dev Initializes the staking contract with admin and golden fisher addresses
@@ -210,10 +253,10 @@ contract Staking {
         if (msg.sender != goldenFisher.actual)
             revert ErrorsLib.SenderIsNotGoldenFisher();
 
-        stakingUserProcess(
-            goldenFisher.actual,
-            amountOfStaking,
+        stakingBaseProcess(
+            AccountMetadata({Address: goldenFisher.actual, IsAService: false}),
             isStaking,
+            amountOfStaking,
             0,
             Evvm(EVVM_ADDRESS).getNextCurrentSyncNonce(msg.sender),
             false,
@@ -263,10 +306,10 @@ contract Staking {
         if (!allowPresaleStaking.flag)
             revert ErrorsLib.PresaleStakingDisabled();
 
-        stakingUserProcess(
-            user,
-            1,
+        stakingBaseProcess(
+            AccountMetadata({Address: user, IsAService: false}),
             isStaking,
+            1,
             priorityFee_EVVM,
             nonce_EVVM,
             priorityFlag_EVVM,
@@ -351,10 +394,10 @@ contract Staking {
         if (checkIfStakeNonceUsed(user, nonce))
             revert ErrorsLib.StakingNonceAlreadyUsed();
 
-        stakingUserProcess(
-            user,
-            amountOfStaking,
+        stakingBaseProcess(
+            AccountMetadata({Address: user, IsAService: false}),
             isStaking,
+            amountOfStaking,
             priorityFee_EVVM,
             nonce_EVVM,
             priorityFlag_EVVM,
@@ -365,146 +408,120 @@ contract Staking {
     }
 
     /**
-     * @notice Allows smart contracts (services) to stake on behalf of users
-     * @dev Verifies that the service address has contract code and handles service-specific logic
-     * @param user Address of the user who owns the stake
-     * @param service Address of the smart contract performing the staking
-     * @param isStaking True for staking, false for unstaking
-     * @param amountOfStaking Amount of staking tokens to stake/unstake
-     * @param nonce Unique nonce for this staking operation
-     * @param signature Signature proving authorization for service staking
-     * @param priorityFee_EVVM Priority fee for the EVVM transaction (only for staking)
-     * @param nonce_EVVM Nonce for the EVVM contract transaction (only for staking)
-     * @param priorityFlag_EVVM Priority flag for EVVM transaction (only for staking)
-     * @param signature_EVVM Signature for the EVVM contract transaction (only for staking)
+     * @notice Prepares a service/contract account for staking by recording pre-staking state
+     * @dev First step in the service staking process. Must be followed by payment via caPay and confirmServiceStaking in the same transaction
+     * @param amountOfStaking Amount of staking tokens the service intends to stake
+     * 
+     * Service Staking Process:
+     * 1. Call prepareServiceStaking(amount) - Records balances and metadata
+     * 2. Use EVVM.caPay() to transfer the required Principal Tokens to this contract  
+     * 3. Call confirmServiceStaking() - Validates payment and completes staking
+     * 
+     * @dev All three steps MUST occur in the same transaction or the staking will fail
+     * @dev CRITICAL WARNING: If the process is not completed properly (especially if caPay is called
+     *      but confirmServiceStaking is not), the Principal Tokens will remain locked in the staking
+     *      contract with no way to recover them. The service will lose the tokens permanently.
+     * @dev Only callable by contract accounts (services), not EOAs
      */
-    function publicServiceStaking(
-        address user,
-        address service,
-        bool isStaking,
-        uint256 amountOfStaking,
-        uint256 nonce,
-        bytes memory signature,
-        uint256 priorityFee_EVVM,
-        uint256 nonce_EVVM,
-        bool priorityFlag_EVVM,
-        bytes memory signature_EVVM
-    ) external {
-        if (!allowPublicStaking.flag) revert ErrorsLib.PublicStakingDisabled();
-
-        uint256 size;
+    function prepareServiceStaking(uint256 amountOfStaking) external onlyCA {
+        serviceStakingData = ServiceStakingMetadata({
+            service: msg.sender,
+            timestamp: block.timestamp,
+            amountOfStaking: amountOfStaking,
+            amountServiceBeforeStaking: Evvm(EVVM_ADDRESS).getBalance(
+                msg.sender,
+                PRINCIPAL_TOKEN_ADDRESS
+            ),
+            amountStakingBeforeStaking: Evvm(EVVM_ADDRESS).getBalance(
+                address(this),
+                PRINCIPAL_TOKEN_ADDRESS
+            )
+        });
+    }
 
-        assembly {
-            /// @dev check the size of the opcode of the address
-            size := extcodesize(service)
-        }
+    /**
+     * @notice Confirms and completes the service staking operation after payment verification
+     * @dev Final step in service staking. Validates that payment was made correctly and completes the staking process
+     * 
+     * Validation checks:
+     * - Service balance decreased by the exact staking cost
+     * - Staking contract balance increased by the exact staking cost  
+     * - Operation occurs in the same transaction as prepareServiceStaking
+     * - Caller matches the service that initiated the preparation
+     * 
+     * @dev Only callable by the same contract that called prepareServiceStaking
+     * @dev Must be called in the same transaction as prepareServiceStaking
+     */
+    function confirmServiceStaking() external onlyCA {
+        uint256 totalStakingRequired = PRICE_OF_STAKING *
+            serviceStakingData.amountOfStaking;
 
-        if (size == 0) revert ErrorsLib.AddressIsNotAService();
+        uint256 actualServiceBalance = Evvm(EVVM_ADDRESS).getBalance(
+            msg.sender,
+            PRINCIPAL_TOKEN_ADDRESS
+        );
 
-        if (isStaking) {
-            if (
-                !SignatureUtils.verifyMessageSignedForPublicServiceStake(
-                    Evvm(EVVM_ADDRESS).getEvvmID(),
-                    user,
-                    service,
-                    isStaking,
-                    amountOfStaking,
-                    nonce,
-                    signature
-                )
-            ) revert ErrorsLib.InvalidSignatureOnStaking();
-        } else {
-            if (service != user) revert ErrorsLib.UserAndServiceMismatch();
-        }
+        uint256 actualStakingBalance = Evvm(EVVM_ADDRESS).getBalance(
+            address(this),
+            PRINCIPAL_TOKEN_ADDRESS
+        );
 
-        if (checkIfStakeNonceUsed(user, nonce))
-            revert ErrorsLib.StakingNonceAlreadyUsed();
+        if (
+            serviceStakingData.amountServiceBeforeStaking -
+                totalStakingRequired !=
+            actualServiceBalance &&
+            serviceStakingData.amountStakingBeforeStaking +
+                totalStakingRequired !=
+            actualStakingBalance
+        )
+            revert ErrorsLib.ServiceDoesNotFulfillCorrectStakingAmount(
+                totalStakingRequired
+            );
 
-        stakingServiceProcess(
-            user,
-            service,
-            isStaking,
-            amountOfStaking,
-            isStaking ? priorityFee_EVVM : 0,
-            isStaking ? nonce_EVVM : 0,
-            isStaking ? priorityFlag_EVVM : false,
-            isStaking ? signature_EVVM : bytes("")
-        );
+        if (serviceStakingData.timestamp != block.timestamp)
+            revert ErrorsLib.ServiceDoesNotStakeInSameTx();
 
-        stakingNonce[user][nonce] = true;
-    }
+        if (serviceStakingData.service != msg.sender)
+            revert ErrorsLib.AddressMismatch();
 
-    /**
-     * @notice Internal function to process service staking operations
-     * @dev Wrapper function that calls the base staking process for service operations
-     * @param user Address of the user who owns the stake
-     * @param service Address of the smart contract performing the staking
-     * @param isStaking True for staking, false for unstaking
-     * @param amountOfStaking Amount of staking tokens to stake/unstake
-     * @param priorityFee_EVVM Priority fee for the EVVM transaction
-     * @param nonce_EVVM Nonce for the EVVM contract transaction
-     * @param priorityFlag_EVVM Priority flag for EVVM transaction
-     * @param signature_EVVM Signature for the EVVM contract transaction
-     */
-    function stakingServiceProcess(
-        address user,
-        address service,
-        bool isStaking,
-        uint256 amountOfStaking,
-        uint256 priorityFee_EVVM,
-        uint256 nonce_EVVM,
-        bool priorityFlag_EVVM,
-        bytes memory signature_EVVM
-    ) internal {
         stakingBaseProcess(
-            user,
-            service,
-            isStaking,
-            amountOfStaking,
-            priorityFee_EVVM,
-            nonce_EVVM,
-            priorityFlag_EVVM,
-            signature_EVVM
+            AccountMetadata({Address: msg.sender, IsAService: true}),
+            true,
+            serviceStakingData.amountOfStaking,
+            0,
+            0,
+            false,
+            ""
         );
     }
 
     /**
-     * @notice Internal function to process user staking operations
-     * @dev Wrapper function that calls the base staking process for user operations
-     * @param user Address of the user performing the staking operation
-     * @param amountOfStaking Amount of staking tokens to stake/unstake
-     * @param isStaking True for staking, false for unstaking
-     * @param priorityFee_EVVM Priority fee for the EVVM transaction
-     * @param nonce_EVVM Nonce for the EVVM contract transaction
-     * @param priorityFlag_EVVM Priority flag for EVVM transaction
-     * @param signature_EVVM Signature for the EVVM contract transaction
+     * @notice Allows a service/contract account to unstake their staking tokens
+     * @dev Simplified unstaking process for services - no signature or payment required, just direct unstaking
+     * @param amountOfStaking Amount of staking tokens to unstake
+     * 
+     * @dev The service will receive Principal Tokens equal to: amountOfStaking * PRICE_OF_STAKING
+     * @dev Subject to the same time locks as regular unstaking (21 days for full unstake)
+     * @dev Only callable by contract accounts (services), not EOAs
      */
-    function stakingUserProcess(
-        address user,
-        uint256 amountOfStaking,
-        bool isStaking,
-        uint256 priorityFee_EVVM,
-        uint256 nonce_EVVM,
-        bool priorityFlag_EVVM,
-        bytes memory signature_EVVM
-    ) internal {
+    function serviceUnstaking(uint256 amountOfStaking) external onlyCA {
         stakingBaseProcess(
-            user,
-            user,
-            isStaking,
+            AccountMetadata({Address: msg.sender, IsAService: true}),
+            false,
             amountOfStaking,
-            priorityFee_EVVM,
-            nonce_EVVM,
-            priorityFlag_EVVM,
-            signature_EVVM
+            0,
+            0,
+            false,
+            ""
         );
     }
 
     /**
      * @notice Core staking logic that handles both service and user staking operations
      * @dev Processes payments, updates history, handles time locks, and manages EVVM integration
-     * @param userAccount Address of the user paying for the transaction
-     * @param stakingAccount Address that will receive the stake/unstake (can be same as userAccount)
+     * @param account Metadata of the account performing the staking operation
+     *                  - Address: Address of the account
+     *                  - IsAService: Boolean indicating if the account is a smart contract (service) account
      * @param isStaking True for staking (requires payment), false for unstaking (provides refund)
      * @param amountOfStaking Amount of staking tokens to stake/unstake
      * @param priorityFee_EVVM Priority fee for EVVM transaction
@@ -513,8 +530,7 @@ contract Staking {
      * @param signature_EVVM Signature for EVVM contract transaction
      */
     function stakingBaseProcess(
-        address userAccount,
-        address stakingAccount,
+        AccountMetadata memory account,
         bool isStaking,
         uint256 amountOfStaking,
         uint256 priorityFee_EVVM,
@@ -526,61 +542,61 @@ contract Staking {
 
         if (isStaking) {
             if (
-                getTimeToUserUnlockStakingTime(stakingAccount) > block.timestamp
-            ) revert ErrorsLib.UserMustWaitToStakeAgain();
-
-            makePay(
-                userAccount,
-                (PRICE_OF_STAKING * amountOfStaking),
-                priorityFee_EVVM,
-                priorityFlag_EVVM,
-                nonce_EVVM,
-                signature_EVVM
-            );
+                getTimeToUserUnlockStakingTime(account.Address) >
+                block.timestamp
+            ) revert ErrorsLib.AddressMustWaitToStakeAgain();
 
-            Evvm(EVVM_ADDRESS).pointStaker(stakingAccount, 0x01);
+            if (!account.IsAService)
+                makePay(
+                    account.Address,
+                    (PRICE_OF_STAKING * amountOfStaking),
+                    priorityFee_EVVM,
+                    priorityFlag_EVVM,
+                    nonce_EVVM,
+                    signature_EVVM
+                );
+
+            Evvm(EVVM_ADDRESS).pointStaker(account.Address, 0x01);
 
-            auxSMsteBalance = userHistory[stakingAccount].length == 0
+            auxSMsteBalance = userHistory[account.Address].length == 0
                 ? amountOfStaking
-                : userHistory[stakingAccount][
-                    userHistory[stakingAccount].length - 1
+                : userHistory[account.Address][
+                    userHistory[account.Address].length - 1
                 ].totalStaked + amountOfStaking;
         } else {
-            if (amountOfStaking == getUserAmountStaked(stakingAccount)) {
+            if (amountOfStaking == getUserAmountStaked(account.Address)) {
                 if (
-                    getTimeToUserUnlockFullUnstakingTime(stakingAccount) >
+                    getTimeToUserUnlockFullUnstakingTime(account.Address) >
                     block.timestamp
-                ) revert ErrorsLib.UserMustWaitToFullUnstake();
+                ) revert ErrorsLib.AddressMustWaitToFullUnstake();
 
-                Evvm(EVVM_ADDRESS).pointStaker(stakingAccount, 0x00);
+                Evvm(EVVM_ADDRESS).pointStaker(account.Address, 0x00);
             }
 
-            // Only for user unstaking, not service
-            if (userAccount == stakingAccount && priorityFee_EVVM != 0) {
+            if (priorityFee_EVVM != 0 && !account.IsAService)
                 makePay(
-                    userAccount,
+                    account.Address,
                     priorityFee_EVVM,
                     0,
                     priorityFlag_EVVM,
                     nonce_EVVM,
                     signature_EVVM
                 );
-            }
 
             auxSMsteBalance =
-                userHistory[stakingAccount][
-                    userHistory[stakingAccount].length - 1
+                userHistory[account.Address][
+                    userHistory[account.Address].length - 1
                 ].totalStaked -
                 amountOfStaking;
 
             makeCaPay(
                 PRINCIPAL_TOKEN_ADDRESS,
-                stakingAccount,
+                account.Address,
                 (PRICE_OF_STAKING * amountOfStaking)
             );
         }
 
-        userHistory[stakingAccount].push(
+        userHistory[account.Address].push(
             HistoryMetadata({
                 transactionType: isStaking
                     ? bytes32(uint256(1))
@@ -591,7 +607,10 @@ contract Staking {
             })
         );
 
-        if (Evvm(EVVM_ADDRESS).isAddressStaker(msg.sender)) {
+        if (
+            Evvm(EVVM_ADDRESS).isAddressStaker(msg.sender) &&
+            !account.IsAService
+        ) {
             makeCaPay(
                 PRINCIPAL_TOKEN_ADDRESS,
                 msg.sender,
@@ -769,16 +788,29 @@ contract Staking {
         admin.timeToAccept = 0;
     }
 
+    /**
+     * @notice Proposes a new golden fisher address with 1-day time delay
+     * @dev Part of the time-delayed governance system for golden fisher changes
+     * @param _goldenFisher Address of the proposed new golden fisher
+     */
     function proposeGoldenFisher(address _goldenFisher) external onlyOwner {
         goldenFisher.proposal = _goldenFisher;
         goldenFisher.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Rejects the current golden fisher proposal
+     * @dev Only current admin can reject the pending golden fisher proposal
+     */
     function rejectProposalGoldenFisher() external onlyOwner {
         goldenFisher.proposal = address(0);
         goldenFisher.timeToAccept = 0;
     }
 
+    /**
+     * @notice Accepts the golden fisher proposal after the time delay has passed
+     * @dev Can only be called by the current admin after the 1-day time delay
+     */
     function acceptNewGoldenFisher() external onlyOwner {
         if (goldenFisher.timeToAccept > block.timestamp) {
             revert();
@@ -788,6 +820,11 @@ contract Staking {
         goldenFisher.timeToAccept = 0;
     }
 
+    /**
+     * @notice Proposes a new time delay for staking after unstaking with 1-day time delay
+     * @dev Part of the time-delayed governance system for staking unlock time changes
+     * @param _secondsToUnlockStaking New number of seconds users must wait after unstaking before staking again
+     */
     function proposeSetSecondsToUnlockStaking(
         uint256 _secondsToUnlockStaking
     ) external onlyOwner {
@@ -795,11 +832,19 @@ contract Staking {
         secondsToUnlockStaking.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Rejects the current staking unlock time proposal
+     * @dev Only current admin can reject the pending staking unlock time proposal
+     */
     function rejectProposalSetSecondsToUnlockStaking() external onlyOwner {
         secondsToUnlockStaking.proposal = 0;
         secondsToUnlockStaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Accepts the staking unlock time proposal after the time delay has passed
+     * @dev Can only be called by the current admin after the 1-day time delay
+     */
     function acceptSetSecondsToUnlockStaking() external onlyOwner {
         if (secondsToUnlockStaking.timeToAccept > block.timestamp) {
             revert();
@@ -809,6 +854,11 @@ contract Staking {
         secondsToUnlockStaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Proposes a new time delay for full unstaking operations with 1-day time delay
+     * @dev Part of the time-delayed governance system for full unstaking time changes
+     * @param _secondsToUnllockFullUnstaking New number of seconds users must wait for full unstaking (default: 21 days)
+     */
     function prepareSetSecondsToUnllockFullUnstaking(
         uint256 _secondsToUnllockFullUnstaking
     ) external onlyOwner {
@@ -816,11 +866,19 @@ contract Staking {
         secondsToUnllockFullUnstaking.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Cancels the current full unstaking time proposal
+     * @dev Only current admin can cancel the pending full unstaking time proposal
+     */
     function cancelSetSecondsToUnllockFullUnstaking() external onlyOwner {
         secondsToUnllockFullUnstaking.proposal = 0;
         secondsToUnllockFullUnstaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Confirms the full unstaking time proposal after the time delay has passed
+     * @dev Can only be called by the current admin after the 1-day time delay
+     */
     function confirmSetSecondsToUnllockFullUnstaking() external onlyOwner {
         if (secondsToUnllockFullUnstaking.timeToAccept > block.timestamp) {
             revert();
@@ -831,14 +889,26 @@ contract Staking {
         secondsToUnllockFullUnstaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Prepares to toggle the public staking flag with 1-day time delay
+     * @dev Initiates the time-delayed process to enable/disable public staking
+     */
     function prepareChangeAllowPublicStaking() external onlyOwner {
         allowPublicStaking.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Cancels the pending public staking flag change
+     * @dev Only current admin can cancel the pending public staking toggle
+     */
     function cancelChangeAllowPublicStaking() external onlyOwner {
         allowPublicStaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Confirms and executes the public staking flag toggle after the time delay has passed
+     * @dev Toggles between enabled/disabled state for public staking after 1-day delay
+     */
     function confirmChangeAllowPublicStaking() external onlyOwner {
         if (allowPublicStaking.timeToAccept > block.timestamp) {
             revert();
@@ -849,14 +919,26 @@ contract Staking {
         });
     }
 
+    /**
+     * @notice Prepares to toggle the presale staking flag with 1-day time delay
+     * @dev Initiates the time-delayed process to enable/disable presale staking
+     */
     function prepareChangeAllowPresaleStaking() external onlyOwner {
         allowPresaleStaking.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Cancels the pending presale staking flag change
+     * @dev Only current admin can cancel the pending presale staking toggle
+     */
     function cancelChangeAllowPresaleStaking() external onlyOwner {
         allowPresaleStaking.timeToAccept = 0;
     }
 
+    /**
+     * @notice Confirms and executes the presale staking flag toggle after the time delay has passed
+     * @dev Toggles between enabled/disabled state for presale staking after 1-day delay
+     */
     function confirmChangeAllowPresaleStaking() external onlyOwner {
         if (allowPresaleStaking.timeToAccept > block.timestamp) {
             revert();
@@ -867,16 +949,29 @@ contract Staking {
         });
     }
 
+    /**
+     * @notice Proposes a new estimator contract address with 1-day time delay
+     * @dev Part of the time-delayed governance system for estimator contract changes
+     * @param _estimator Address of the proposed new estimator contract
+     */
     function proposeEstimator(address _estimator) external onlyOwner {
         estimator.proposal = _estimator;
         estimator.timeToAccept = block.timestamp + 1 days;
     }
 
+    /**
+     * @notice Rejects the current estimator contract proposal
+     * @dev Only current admin can reject the pending estimator contract proposal
+     */
     function rejectProposalEstimator() external onlyOwner {
         estimator.proposal = address(0);
         estimator.timeToAccept = 0;
     }
 
+    /**
+     * @notice Accepts the estimator contract proposal after the time delay has passed
+     * @dev Can only be called by the current admin after the 1-day time delay
+     */
     function acceptNewEstimator() external onlyOwner {
         if (estimator.timeToAccept > block.timestamp) {
             revert();

package/contracts/staking/lib/ErrorsLib.sol

@@ -14,6 +14,10 @@ library ErrorsLib {
     error PublicStakingDisabled();
     error AddressIsNotAService();
     error UserAndServiceMismatch();
-    error UserMustWaitToStakeAgain();
-    error UserMustWaitToFullUnstake();
+    error AddressMustWaitToStakeAgain();
+    error AddressMustWaitToFullUnstake();
+    error ServiceDoesNotFulfillCorrectStakingAmount(uint256 requiredAmount);
+    error ServiceDoesNotStakeInSameTx();
+    error AddressMismatch();
 }
+

package/contracts/treasury/Treasury.sol

@@ -22,7 +22,7 @@ pragma solidity ^0.8.0;
    ╚═╝   ╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚══════╝   ╚═╝   
             
  * @title Treasury Contract
- * @author jistro.eth
+ * @author Mate labs
  * @notice Treasury for managing deposits and withdrawals in the EVVM ecosystem
  * @dev Secure vault for ETH and ERC20 tokens with EVVM integration and input validation
  */

package/library/Erc191TestBuilder.sol

@@ -4,7 +4,7 @@
 pragma solidity ^0.8.0;
 /**
  * @title Erc191TestBuilder
- * @author jistro.eth
+ * @author Mate labs
  * @notice this library is used to build ERC191 messages for foundry test scripts
  *         more info in
  *         https://book.getfoundry.sh/cheatcodes/create-wallet

package/library/SignatureRecover.sol

@@ -3,9 +3,59 @@
 
 pragma solidity ^0.8.0;
 
+/**
+ * @title SignatureRecover
+ * @author Mate labs
+ * @notice Library for ECDSA signature verification and signer recovery in the EVVM ecosystem
+ * @dev Provides utilities for verifying signatures against expected signers and recovering addresses from signatures.
+ *      Uses ERC-191 standard message signing format with proper message hashing and signature validation.
+ *
+ * Key Features:
+ * - EVVM-specific signature verification with structured message format
+ * - ERC-191 compliant signature format (\x19Ethereum Signed Message)
+ * - Safe signature splitting and validation
+ * - Address recovery from message signatures
+ *
+ * Security Features:
+ * - Validates signature length (must be 65 bytes)
+ * - Ensures proper v value (27 or 28)
+ * - Uses keccak256 hashing with ERC-191 message prefix
+ * - Prevents signature malleability attacks
+ *
+ * Usage Pattern:
+ * ```solidity
+ * bool isValid = SignatureRecover.signatureVerification(
+ *     evvmID,
+ *     "functionName",
+ *     string.concat(param1, ",", param2, ",", param3),
+ *     signature,
+ *     expectedAddress
+ * );
+ * ```
+ */
+
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 
 library SignatureRecover {
+    /**
+     * @notice Verifies that a signature matches the expected signer for EVVM operations
+     * @dev Constructs a standardized message format and verifies the signature against the expected signer
+     *
+     * Message Format: "{evvmID},{functionName},{inputs}"
+     * This creates a unique signature for each EVVM operation preventing replay attacks across:
+     * - Different EVVM instances (via evvmID)
+     * - Different functions (via functionName)
+     * - Different parameters (via inputs)
+     *
+     * @param evvmID Unique identifier for the EVVM instance (prevents cross-chain replay)
+     * @param functionName Name of the function being called (prevents cross-function replay)
+     * @param inputs Comma-separated string of function inputs. Must be constructed using 
+     *               string.concat(param1, ",", param2, ",", param3) 
+     *               where all parameters are converted to strings
+     * @param signature The ECDSA signature to verify (65 bytes: r(32) + s(32) + v(1))
+     * @param expectedSigner Address that should have signed the message
+     * @return bool True if the signature is valid and matches the expected signer, false otherwise
+     */
     function signatureVerification(
         string memory evvmID,
         string memory functionName,
@@ -20,7 +70,22 @@ library SignatureRecover {
             ) == expectedSigner;
     }
 
-    
+    /**
+     * @notice Recovers the signer address from a message and its signature
+     * @dev Uses ERC-191 standard message signing format with proper prefix and length encoding
+     *
+     * The message is hashed using the ERC-191 standard format:
+     * keccak256("\x19Ethereum Signed Message:\n" + messageLength + message)
+     *
+     * This ensures compatibility with standard Ethereum wallets and signing tools like:
+     * - MetaMask personal_sign
+     * - web3.eth.personal.sign
+     * - ethers.js signMessage
+     *
+     * @param message The original message that was signed (plain text)
+     * @param signature The ECDSA signature (65 bytes: r + s + v)
+     * @return address The recovered signer address, or zero address if signature is invalid
+     */
     function recoverSigner(
         string memory message,
         bytes memory signature
@@ -36,6 +101,25 @@ library SignatureRecover {
         return ecrecover(messageHash, v, r, s);
     }
 
+    /**
+     * @notice Splits a signature into its component parts (r, s, v)
+     * @dev Extracts r, s, and v values from a 65-byte signature and validates the format
+     *
+     * Signature Format (65 bytes total):
+     * - r: bytes 0-31 (32 bytes) - First part of ECDSA signature
+     * - s: bytes 32-63 (32 bytes) - Second part of ECDSA signature
+     * - v: byte 64 (1 byte) - Recovery identifier (27 or 28)
+     *
+     * Security validations:
+     * - Ensures signature is exactly 65 bytes
+     * - Normalizes v value to 27/28 if needed
+     * - Validates v is either 27 or 28 (standard Ethereum values)
+     *
+     * @param signature The complete signature bytes to split (must be 65 bytes)
+     * @return r The r component of the signature (bytes32)
+     * @return s The s component of the signature (bytes32)
+     * @return v The recovery identifier (uint8, either 27 or 28)
+     */
     function splitSignature(
         bytes memory signature
     ) internal pure returns (bytes32 r, bytes32 s, uint8 v) {

package/library/StakingServiceHooks.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+pragma solidity ^0.8.0;
+
+/**
+ * @title StakingServiceHooks
+ * @author Mate labs
+ * @notice Abstract contract providing simplified staking functionality for service contracts
+ * @dev This contract provides pre-built hooks for service contracts to easily interact with the EVVM staking system.
+ *      It handles the complex 3-step staking process atomically to prevent token loss.
+ * 
+ * Key Features:
+ * - Atomic service staking: Combines prepareServiceStaking, caPay, and confirmServiceStaking in one call
+ * - Simplified unstaking for services
+ * - Automatic address management for Staking and EVVM contracts
+ * - Safe state management to prevent token loss
+ * 
+ * Usage:
+ * - Inherit from this contract in your service contract
+ * - Call makeStakeService(amount) to stake tokens safely
+ * - Call makeUnstakeService(amount) to unstake tokens
+ * 
+ * IMPORTANT: The service contract must have sufficient Principal Token balance before calling makeStakeService
+ */
+
+import {Staking} from "@evvm/testnet-contracts/contracts/staking/Staking.sol";
+import {Evvm} from "@evvm/testnet-contracts/contracts/evvm/Evvm.sol";
+
+abstract contract StakingServiceHooks {
+    /// @dev Address of the Staking contract that handles staking operations
+    address stakingHookAddress;
+    /// @dev Address of the EVVM core contract that handles token operations
+    address evvmHookAddress;
+    
+    /**
+     * @notice Initializes the service hooks with the staking contract address
+     * @dev Automatically retrieves and stores the EVVM contract address from the staking contract
+     * @param _stakingAddress Address of the deployed Staking contract
+     */
+    constructor(address _stakingAddress) {
+        stakingHookAddress = _stakingAddress;
+        evvmHookAddress = Staking(stakingHookAddress).getEvvmAddress();
+    }
+    
+    /**
+     * @notice Performs atomic staking operation for the service contract
+     * @dev Executes the complete 3-step staking process in a single transaction to prevent token loss:
+     *      1. Prepares service staking (records pre-staking state)
+     *      2. Transfers Principal Tokens to staking contract via caPay
+     *      3. Confirms staking completion
+     * 
+     * @param amountToStake Number of staking tokens to stake (not Principal Tokens)
+     * 
+     * Requirements:
+     * - Service must have sufficient Principal Token balance (amountToStake * PRICE_OF_STAKING)
+     * - Service must not be in cooldown period from previous unstaking
+     * - All operations must succeed in the same transaction
+     * 
+     * @dev CRITICAL: This function ensures atomicity - if any step fails, the entire transaction reverts
+     *      preventing the loss of Principal Tokens that could occur with manual step-by-step execution
+     */
+    function makeStakeService(uint256 amountToStake) public {
+        Staking(stakingHookAddress).prepareServiceStaking(amountToStake);
+        Evvm(evvmHookAddress).caPay(
+            address(stakingHookAddress),
+            0x0000000000000000000000000000000000000001,
+            Staking(stakingHookAddress).priceOfStaking() * amountToStake
+        );
+        Staking(stakingHookAddress).confirmServiceStaking();
+    }
+
+    /**
+     * @notice Performs unstaking operation for the service contract
+     * @dev Allows the service to withdraw staked tokens and receive Principal Tokens back
+     * 
+     * @param amountToUnstake Number of staking tokens to unstake
+     * 
+     * The service will receive: amountToUnstake * PRICE_OF_STAKING Principal Tokens
+     * 
+     * Requirements:
+     * - Service must have at least amountToUnstake staking tokens staked
+     * - If unstaking all tokens, must wait 21 days since last zero balance
+     * - Cannot unstake more than currently staked amount
+     * 
+     * @dev Unstaking is subject to the same time locks as regular user unstaking
+     */
+    function makeUnstakeService(uint256 amountToUnstake) public {
+        Staking(stakingHookAddress).serviceUnstaking(amountToUnstake);
+    }
+
+    /**
+     * @notice Internal function to update the staking contract address
+     * @dev Updates both staking and EVVM addresses. Should be used when staking contract is upgraded
+     * @param newStakingAddress Address of the new Staking contract
+     * 
+     * @dev This function should be called by inheriting contracts when they need to migrate
+     *      to a new version of the staking contract. It automatically updates the EVVM address too.
+     */
+    function _changeStakingHookAddress(address newStakingAddress) internal {
+        stakingHookAddress = newStakingAddress;
+        evvmHookAddress = Staking(stakingHookAddress).getEvvmAddress();
+    }
+
+    /**
+     * @notice Internal function to manually update the EVVM contract address
+     * @dev Updates only the EVVM address. Use when EVVM contract is upgraded independently
+     * @param newEvvmAddress Address of the new EVVM contract
+     * 
+     * @dev This function should be used sparingly, typically only when the EVVM contract
+     *      is upgraded but the staking contract remains the same. In most cases, prefer
+     *      using _changeStakingHookAddress which updates both addresses automatically.
+     */
+    function changeEvvmHookAddress(address newEvvmAddress) internal {
+        evvmHookAddress = newEvvmAddress;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evvm/testnet-contracts",
-  "version": "1.0.7",
+  "version": "2.0.0",
   "description": "EVVM Testnet Contracts - Smart contracts and tools for scalable, modular, and cross-chain EVM virtualization",
   "files": [
     "contracts/**/*.sol",