@evvm/testnet-contracts 2.1.3 → 2.2.0

package/library/AdvancedStrings.sol

@@ -1,77 +0,0 @@
-// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
-// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
-
-pragma solidity ^0.8.0;
-
-import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-
-library AdvancedStrings {
-    function addressToString(
-        address _address
-    ) internal pure returns (string memory) {
-        bytes32 _bytes = bytes32(uint256(uint160(_address)));
-        bytes memory HEX = "0123456789abcdef";
-        bytes memory _string = new bytes(42);
-        _string[0] = "0";
-        _string[1] = "x";
-        for (uint256 i = 0; i < 20; i++) {
-            _string[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
-            _string[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
-        }
-        return string(_string);
-    }
-
-    function toHex16(bytes16 data) internal pure returns (bytes32 result) {
-        result =
-            (bytes32(data) &
-                0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000) |
-            ((bytes32(data) &
-                0x0000000000000000FFFFFFFFFFFFFFFF00000000000000000000000000000000) >>
-                64);
-        result =
-            (result &
-                0xFFFFFFFF000000000000000000000000FFFFFFFF000000000000000000000000) |
-            ((result &
-                0x00000000FFFFFFFF000000000000000000000000FFFFFFFF0000000000000000) >>
-                32);
-        result =
-            (result &
-                0xFFFF000000000000FFFF000000000000FFFF000000000000FFFF000000000000) |
-            ((result &
-                0x0000FFFF000000000000FFFF000000000000FFFF000000000000FFFF00000000) >>
-                16);
-        result =
-            (result &
-                0xFF000000FF000000FF000000FF000000FF000000FF000000FF000000FF000000) |
-            ((result &
-                0x00FF000000FF000000FF000000FF000000FF000000FF000000FF000000FF0000) >>
-                8);
-        result =
-            ((result &
-                0xF000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000) >>
-                4) |
-            ((result &
-                0x0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00) >>
-                8);
-        result = bytes32(
-            0x3030303030303030303030303030303030303030303030303030303030303030 +
-                uint256(result) +
-                (((uint256(result) +
-                    0x0606060606060606060606060606060606060606060606060606060606060606) >>
-                    4) &
-                    0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F) *
-                7
-        );
-    }
-
-    function bytes32ToString(bytes32 data) public pure returns (string memory) {
-        return
-            string(
-                abi.encodePacked(
-                    "0x",
-                    toHex16(bytes16(data)),
-                    toHex16(bytes16(data << 128))
-                )
-            );
-    }
-}

package/library/SignatureRecover.sol

@@ -1,140 +0,0 @@
-// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
-// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
-
-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,
-        string memory inputs,
-        bytes memory signature,
-        address expectedSigner
-    ) internal pure returns (bool) {
-        return
-            recoverSigner(
-                string.concat(evvmID, ",", functionName, ",", inputs),
-                signature
-            ) == 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
-    ) internal pure returns (address) {
-        bytes32 messageHash = keccak256(
-            abi.encodePacked(
-                "\x19Ethereum Signed Message:\n",
-                Strings.toString(bytes(message).length),
-                message
-            )
-        );
-        (bytes32 r, bytes32 s, uint8 v) = splitSignature(signature);
-        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) {
-        require(signature.length == 65, "Invalid signature length");
-
-        assembly {
-            r := mload(add(signature, 32))
-            s := mload(add(signature, 64))
-            v := byte(0, mload(add(signature, 96)))
-        }
-
-        // Ensure signature is valid
-        if (v < 27) {
-            v += 27;
-        }
-        require(v == 27 || v == 28, "Invalid signature value");
-    }
-}

package/library/StakingServiceHooks.sol

@@ -1,116 +0,0 @@
-// 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) internal {
-        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) internal {
-        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;
-    }
-}