@evvm/testnet-contracts 2.2.0 → 2.2.1

package/contracts/nameService/lib/ErrorsLib.sol

@@ -8,13 +8,7 @@ library ErrorsLib {
     error UserIsNotOwnerOfIdentity();
     error NonceAlreadyUsed();
     error InvalidSignatureOnNameService();
-    /**
-     * @dev Error thrown when a username is not valid.
-     *      0x01 - Username is too short.
-     *      0x02 - Username does not start with a letter.
-     *      0x03 - Username contains invalid characters.
-     */
-    error InvalidUsername(bytes1);
+    error InvalidUsername();
     error UsernameAlreadyRegistered();
     error PreRegistrationNotValid();
     error MakeOfferVerificationFailed();

package/contracts/nameService/lib/IdentityValidation.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library IdentityValidation{
+    /**
+     * @notice Validates username format according to system rules
+     * @dev Username must be at least 4 characters, start with a letter, and contain only letters/digits
+     * @param username The username string to validate
+     */
+    function isValidUsername(string memory username) internal pure returns (bool) {
+        bytes memory usernameBytes = bytes(username);
+
+        // Check if username length is at least 4 characters
+        if (usernameBytes.length < 4) return false;
+
+        // Check if username begins with a letter
+        if (!_isLetter(usernameBytes[0]))
+            return false;
+
+
+        // Iterate through each character in the username
+        for (uint256 i = 0; i < usernameBytes.length; i++) {
+            // Check if character is not a digit or letter
+            if (!_isDigit(usernameBytes[i]) && !_isLetter(usernameBytes[i])) {
+                return false;
+
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @notice Validates phone number format
+     * @dev Phone number must be 6-19 digits only
+     * @param _phoneNumber The phone number string to validate
+     * @return True if valid phone number format
+     */
+    function isValidPhoneNumberNumber(
+        string memory _phoneNumber
+    ) internal pure returns (bool) {
+        bytes memory _telephoneNumberBytes = bytes(_phoneNumber);
+        if (
+            _telephoneNumberBytes.length < 20 &&
+            _telephoneNumberBytes.length > 5
+        ) {
+            return false;
+        }
+        for (uint256 i = 0; i < _telephoneNumberBytes.length; i++) {
+            if (!_isDigit(_telephoneNumberBytes[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @notice Validates email address format
+     * @dev Checks for proper email structure: prefix(3+ chars) + @ + domain(3+ chars) + . + TLD(2+ chars)
+     * @param _email The email address string to validate
+     * @return True if valid email format
+     */
+    function isValidEmail(string memory _email) internal pure returns (bool) {
+        bytes memory _emailBytes = bytes(_email);
+        uint256 lengthCount = 0;
+        bytes1 flagVerify = 0x00;
+        for (uint point = 0; point < _emailBytes.length; point++) {
+            //step 1 0x00 prefix
+            if (flagVerify == 0x00) {
+                if (_isOnlyEmailPrefixCharacters(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAAt(_emailBytes[point])) {
+                        flagVerify = 0x01;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            //step 2 0x01 count the prefix length
+            if (flagVerify == 0x01) {
+                if (lengthCount < 3) {
+                    return false;
+                } else {
+                    flagVerify = 0x02;
+                    lengthCount = 0;
+                    point++;
+                }
+            }
+
+            //step 3 0x02 domain name
+            if (flagVerify == 0x02) {
+                if (_isLetter(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAPoint(_emailBytes[point])) {
+                        flagVerify = 0x03;
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            //step 4 0x03 count the domain name length
+            if (flagVerify == 0x03) {
+                if (lengthCount < 3) {
+                    return false;
+                } else {
+                    flagVerify = 0x04;
+                    lengthCount = 0;
+                    point++;
+                }
+            }
+
+            //step 5 0x04 top level domain
+            if (flagVerify == 0x04) {
+                if (_isLetter(_emailBytes[point])) {
+                    lengthCount++;
+                } else {
+                    if (_isAPoint(_emailBytes[point])) {
+                        if (lengthCount < 2) {
+                            return false;
+                        } else {
+                            lengthCount = 0;
+                        }
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        if (flagVerify != 0x04) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// @dev Checks if a byte represents a digit (0-9)
+    function _isDigit(bytes1 character) private pure returns (bool) {
+        return (character >= 0x30 && character <= 0x39); // ASCII range for digits 0-9
+    }
+
+    /// @dev Checks if a byte represents a letter (A-Z or a-z)
+    function _isLetter(bytes1 character) private pure returns (bool) {
+        return ((character >= 0x41 && character <= 0x5A) ||
+            (character >= 0x61 && character <= 0x7A)); // ASCII ranges for letters A-Z and a-z
+    }
+
+    /// @dev Checks if a byte represents any symbol character
+    function _isAnySimbol(bytes1 character) private pure returns (bool) {
+        return ((character >= 0x21 && character <= 0x2F) || /// @dev includes characters from "!" to "/"
+            (character >= 0x3A && character <= 0x40) || /// @dev includes characters from ":" to "@"
+            (character >= 0x5B && character <= 0x60) || /// @dev includes characters from "[" to "`"
+            (character >= 0x7B && character <= 0x7E)); /// @dev includes characters from "{" to "~"
+    }
+
+    /// @dev Checks if a byte is valid for email prefix (letters, digits, and specific symbols)
+    function _isOnlyEmailPrefixCharacters(
+        bytes1 character
+    ) private pure returns (bool) {
+        return (_isLetter(character) ||
+            _isDigit(character) ||
+            (character >= 0x21 && character <= 0x2F) || /// @dev includes characters from "!" to "/"
+            (character >= 0x3A && character <= 0x3F) || /// @dev includes characters from ":" to "?"
+            (character >= 0x5B && character <= 0x60) || /// @dev includes characters from "[" to "`"
+            (character >= 0x7B && character <= 0x7E)); /// @dev includes characters from "{" to "~"
+    }
+
+    /// @dev Checks if a byte represents a period/dot character (.)
+    function _isAPoint(bytes1 character) private pure returns (bool) {
+        return character == 0x2E;
+    }
+
+    /// @dev Checks if a byte represents an at symbol (@)
+    function _isAAt(bytes1 character) private pure returns (bool) {
+        return character == 0x40;
+    }
+}

package/contracts/nameService/lib/NameServiceStructs.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+abstract contract NameServiceStructs {
+    /**
+     * @dev Struct for managing address change proposals with time delay
+     * @param current Currently active address
+     * @param proposal Proposed new address waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing uint256 value proposals with time delay
+     * @param current Currently active value
+     * @param proposal Proposed new value waiting for approval
+     * @param timeToAccept Timestamp when the proposal can be accepted
+     */
+    struct UintTypeProposal {
+        uint256 current;
+        uint256 proposal;
+        uint256 timeToAccept;
+    }
+
+    /**
+     * @dev Struct for managing boolean flag changes with time delay
+     * @param flag Current boolean state
+     * @param timeToAcceptChange Timestamp when the flag change can be executed
+     */
+    struct BoolTypeProposal {
+        bool flag;
+        uint256 timeToAcceptChange;
+    }
+
+    /**
+     * @dev Core metadata for each registered identity/username
+     * @param owner Address that owns this identity
+     * @param expireDate Timestamp when the registration expires
+     * @param customMetadataMaxSlots Number of custom metadata entries stored
+     * @param offerMaxSlots Maximum number of offers that have been made
+     * @param flagNotAUsername Flag indicating if this is a pre-registration (0x01) or actual username (0x00)
+     */
+    struct IdentityBaseMetadata {
+        address owner;
+        uint256 expireDate;
+        uint256 customMetadataMaxSlots;
+        uint256 offerMaxSlots;
+        bytes1 flagNotAUsername;
+    }
+
+
+    /**
+     * @dev Metadata for marketplace offers on usernames
+     * @param offerer Address making the offer
+     * @param expireDate Timestamp when the offer expires
+     * @param amount Amount offered in Principal Tokens (after 0.5% marketplace fee deduction)
+     */
+    struct OfferMetadata {
+        address offerer;
+        uint256 expireDate;
+        uint256 amount;
+    }
+}

package/contracts/nameService/lib/SignatureUtils.sol

@@ -1,11 +1,10 @@
 // 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";
 
-pragma solidity ^0.8.0;
-
 library SignatureUtils {
     /**
      *  @dev using EIP-191 (https://eips.ethereum.org/EIPS/eip-191) can be used to sign and
@@ -213,7 +212,11 @@ library SignatureUtils {
             SignatureUtil.verifySignature(
                 evvmID,
                 "flushCustomMetadata",
-                string.concat(_identity, ",", AdvancedStrings.uintToString(_nonce)),
+                string.concat(
+                    _identity,
+                    ",",
+                    AdvancedStrings.uintToString(_nonce)
+                ),
                 signature,
                 signer
             );
@@ -230,7 +233,11 @@ library SignatureUtils {
             SignatureUtil.verifySignature(
                 evvmID,
                 "flushUsername",
-                string.concat(_username, ",", AdvancedStrings.uintToString(_nonce)),
+                string.concat(
+                    _username,
+                    ",",
+                    AdvancedStrings.uintToString(_nonce)
+                ),
                 signature,
                 signer
             );

package/contracts/p2pSwap/P2PSwap.sol

@@ -36,77 +36,25 @@ pragma solidity ^0.8.0;
  * - Staker Rewards: 10% (configurable)
  */
 
-import {Evvm} from "@evvm/testnet-contracts/contracts/evvm/Evvm.sol";
 import {Staking} from "@evvm/testnet-contracts/contracts/staking/Staking.sol";
-import {AdvancedStrings} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
-import {EvvmStructs} from "@evvm/testnet-contracts/contracts/evvm/lib/EvvmStructs.sol";
-import {StakingServiceUtils} from "@evvm/testnet-contracts/library/utils/service/StakingServiceUtils.sol";
 import {SignatureUtils} from "@evvm/testnet-contracts/contracts/p2pSwap/lib/SignatureUtils.sol";
-
-contract P2PSwap is StakingServiceUtils {
+import {AdvancedStrings} from "@evvm/testnet-contracts/library/utils/AdvancedStrings.sol";
+import {P2PSwapStructs} from "@evvm/testnet-contracts/contracts/p2pSwap/lib/P2PSwapStructs.sol";
+import {EvvmStructs} from "@evvm/testnet-contracts/interfaces/IEvvm.sol";
+import {EvvmService} from "@evvm/testnet-contracts/library/EvvmService.sol";
+
+contract P2PSwap is
+    EvvmService,
+    P2PSwapStructs
+{
     address owner;
     address owner_proposal;
     uint256 owner_timeToAccept;
 
-    address evvmAddress;
-    address stakingAddress;
-
     address constant MATE_TOKEN_ADDRESS =
         0x0000000000000000000000000000000000000001;
     address constant ETH_ADDRESS = 0x0000000000000000000000000000000000000000;
 
-    struct MarketInformation {
-        address tokenA;
-        address tokenB;
-        uint256 maxSlot;
-        uint256 ordersAvailable;
-    }
-
-    struct Order {
-        address seller;
-        uint256 amountA;
-        uint256 amountB;
-    }
-
-    struct OrderForGetter {
-        uint256 marketId;
-        uint256 orderId;
-        address seller;
-        uint256 amountA;
-        uint256 amountB;
-    }
-
-    struct Percentage {
-        uint256 seller;
-        uint256 service;
-        uint256 mateStaker;
-    }
-
-    struct MetadataMakeOrder {
-        uint256 nonce;
-        address tokenA;
-        address tokenB;
-        uint256 amountA;
-        uint256 amountB;
-    }
-
-    struct MetadataCancelOrder {
-        uint256 nonce;
-        address tokenA;
-        address tokenB;
-        uint256 orderId;
-        bytes signature;
-    }
-
-    struct MetadataDispatchOrder {
-        uint256 nonce;
-        address tokenA;
-        address tokenB;
-        uint256 orderId;
-        uint256 amountOfTokenBToFill;
-        bytes signature;
-    }
-
     Percentage rewardPercentage;
     Percentage rewardPercentage_proposal;
     uint256 rewardPercentage_timeToAcceptNewChange;
@@ -126,8 +74,6 @@ contract P2PSwap is StakingServiceUtils {
 
     uint256 marketCount;
 
-    mapping(address user => mapping(uint256 nonce => bool isUsed)) nonceP2PSwap;
-
     mapping(address tokenA => mapping(address tokenB => uint256 id)) marketId;
 
     mapping(uint256 id => MarketInformation info) marketMetadata;
@@ -140,8 +86,9 @@ contract P2PSwap is StakingServiceUtils {
         address _evvmAddress,
         address _stakingAddress,
         address _owner
-    ) StakingServiceUtils(_stakingAddress) {
-        evvmAddress = _evvmAddress;
+    )
+        EvvmService(_evvmAddress, _stakingAddress)
+    {
         owner = _owner;
         maxLimitFillFixedFee = 0.001 ether;
         percentageFee = 500;
@@ -150,7 +97,6 @@ contract P2PSwap is StakingServiceUtils {
             service: 4000,
             mateStaker: 1000
         });
-        stakingAddress = _stakingAddress;
     }
 
     function makeOrder(
@@ -164,7 +110,7 @@ contract P2PSwap is StakingServiceUtils {
     ) external returns (uint256 market, uint256 orderId) {
         if (
             !SignatureUtils.verifyMessageSignedForMakeOrder(
-                Evvm(evvmAddress).getEvvmID(),
+                evvm.getEvvmID(),
                 user,
                 metadata.nonce,
                 metadata.tokenA,
@@ -177,11 +123,9 @@ contract P2PSwap is StakingServiceUtils {
             revert("Invalid signature");
         }
 
-        if (nonceP2PSwap[user][metadata.nonce]) {
-            revert("Nonce already used");
-        }
+        verifyAsyncNonce(user, metadata.nonce);
 
-        makePay(
+        requestPay(
             user,
             metadata.tokenA,
             _nonce_Evvm,
@@ -219,7 +163,7 @@ contract P2PSwap is StakingServiceUtils {
             metadata.amountB
         );
 
-        if (Evvm(evvmAddress).isAddressStaker(msg.sender)) {
+        if (evvm.isAddressStaker(msg.sender)) {
             if (_priorityFee_Evvm > 0) {
                 // send the executor the priorityFee
                 makeCaPay(msg.sender, metadata.tokenA, _priorityFee_Evvm);
@@ -230,12 +174,12 @@ contract P2PSwap is StakingServiceUtils {
                 msg.sender,
                 MATE_TOKEN_ADDRESS,
                 _priorityFee_Evvm > 0
-                    ? (Evvm(evvmAddress).getRewardAmount() * 3)
-                    : (Evvm(evvmAddress).getRewardAmount() * 2)
+                    ? (evvm.getRewardAmount() * 3)
+                    : (evvm.getRewardAmount() * 2)
             );
         }
 
-        nonceP2PSwap[user][metadata.nonce] = true;
+        markAsyncNonceAsUsed(user, metadata.nonce);
     }
 
     function cancelOrder(
@@ -248,7 +192,7 @@ contract P2PSwap is StakingServiceUtils {
     ) external {
         if (
             !SignatureUtils.verifyMessageSignedForCancelOrder(
-                Evvm(evvmAddress).getEvvmID(),
+                evvm.getEvvmID(),
                 user,
                 metadata.nonce,
                 metadata.tokenA,
@@ -262,9 +206,7 @@ contract P2PSwap is StakingServiceUtils {
 
         uint256 market = findMarket(metadata.tokenA, metadata.tokenB);
 
-        if (nonceP2PSwap[user][metadata.nonce]) {
-            revert("Invalid nonce");
-        }
+        verifyAsyncNonce(user, metadata.nonce);
 
         if (
             market == 0 ||
@@ -274,7 +216,7 @@ contract P2PSwap is StakingServiceUtils {
         }
 
         if (_priorityFee_Evvm > 0) {
-            makePay(
+            requestPay(
                 user,
                 MATE_TOKEN_ADDRESS,
                 _nonce_Evvm,
@@ -293,18 +235,17 @@ contract P2PSwap is StakingServiceUtils {
 
         ordersInsideMarket[market][metadata.orderId].seller = address(0);
 
-        if (Evvm(evvmAddress).isAddressStaker(msg.sender)) {
+        if (evvm.isAddressStaker(msg.sender)) {
             makeCaPay(
                 msg.sender,
                 MATE_TOKEN_ADDRESS,
                 _priorityFee_Evvm > 0
-                    ? ((Evvm(evvmAddress).getRewardAmount() * 3) +
-                        _priorityFee_Evvm)
-                    : (Evvm(evvmAddress).getRewardAmount() * 2)
+                    ? ((evvm.getRewardAmount() * 3) + _priorityFee_Evvm)
+                    : (evvm.getRewardAmount() * 2)
             );
         }
         marketMetadata[market].ordersAvailable--;
-        nonceP2PSwap[user][metadata.nonce] = true;
+        markAsyncNonceAsUsed(user, metadata.nonce);
     }
 
     function dispatchOrder_fillPropotionalFee(
@@ -317,7 +258,7 @@ contract P2PSwap is StakingServiceUtils {
     ) external {
         if (
             !SignatureUtils.verifyMessageSignedForDispatchOrder(
-                Evvm(evvmAddress).getEvvmID(),
+                evvm.getEvvmID(),
                 user,
                 metadata.nonce,
                 metadata.tokenA,
@@ -331,9 +272,7 @@ contract P2PSwap is StakingServiceUtils {
 
         uint256 market = findMarket(metadata.tokenA, metadata.tokenB);
 
-        if (nonceP2PSwap[user][metadata.nonce]) {
-            revert("Invalid nonce");
-        }
+        verifyAsyncNonce(user, metadata.nonce);
 
         if (
             market == 0 ||
@@ -353,7 +292,7 @@ contract P2PSwap is StakingServiceUtils {
             revert("Insuficient amountOfTokenToFill");
         }
 
-        makePay(
+        requestPay(
             user,
             metadata.tokenB,
             _nonce_Evvm,
@@ -412,20 +351,20 @@ contract P2PSwap is StakingServiceUtils {
             ordersInsideMarket[market][metadata.orderId].amountA
         );
 
-        if (Evvm(evvmAddress).isAddressStaker(msg.sender)) {
+        if (evvm.isAddressStaker(msg.sender)) {
             makeCaPay(
                 msg.sender,
                 MATE_TOKEN_ADDRESS,
                 metadata.amountOfTokenBToFill >
                     ordersInsideMarket[market][metadata.orderId].amountB + fee
-                    ? Evvm(evvmAddress).getRewardAmount() * 5
-                    : Evvm(evvmAddress).getRewardAmount() * 4
+                    ? evvm.getRewardAmount() * 5
+                    : evvm.getRewardAmount() * 4
             );
         }
 
         ordersInsideMarket[market][metadata.orderId].seller = address(0);
         marketMetadata[market].ordersAvailable--;
-        nonceP2PSwap[user][metadata.nonce] = true;
+        markAsyncNonceAsUsed(user, metadata.nonce);
     }
 
     function dispatchOrder_fillFixedFee(
@@ -439,7 +378,7 @@ contract P2PSwap is StakingServiceUtils {
     ) external {
         if (
             !SignatureUtils.verifyMessageSignedForDispatchOrder(
-                Evvm(evvmAddress).getEvvmID(),
+                evvm.getEvvmID(),
                 user,
                 metadata.nonce,
                 metadata.tokenA,
@@ -453,9 +392,7 @@ contract P2PSwap is StakingServiceUtils {
 
         uint256 market = findMarket(metadata.tokenA, metadata.tokenB);
 
-        if (nonceP2PSwap[user][metadata.nonce]) {
-            revert("Invalid nonce");
-        }
+        verifyAsyncNonce(user, metadata.nonce);
 
         if (
             market == 0 ||
@@ -476,7 +413,7 @@ contract P2PSwap is StakingServiceUtils {
             revert("Insuficient amountOfTokenBToFill");
         }
 
-        makePay(
+        requestPay(
             user,
             metadata.tokenB,
             _nonce_Evvm,
@@ -539,20 +476,20 @@ contract P2PSwap is StakingServiceUtils {
             ordersInsideMarket[market][metadata.orderId].amountA
         );
 
-        if (Evvm(evvmAddress).isAddressStaker(msg.sender)) {
+        if (evvm.isAddressStaker(msg.sender)) {
             makeCaPay(
                 msg.sender,
                 MATE_TOKEN_ADDRESS,
                 metadata.amountOfTokenBToFill >
                     ordersInsideMarket[market][metadata.orderId].amountB + fee
-                    ? Evvm(evvmAddress).getRewardAmount() * 5
-                    : Evvm(evvmAddress).getRewardAmount() * 4
+                    ? evvm.getRewardAmount() * 5
+                    : evvm.getRewardAmount() * 4
             );
         }
 
         ordersInsideMarket[market][metadata.orderId].seller = address(0);
         marketMetadata[market].ordersAvailable--;
-        nonceP2PSwap[user][metadata.nonce] = true;
+        markAsyncNonceAsUsed(user, metadata.nonce);
     }
 
     //devolver el 0.05% del monto de la orden
@@ -585,49 +522,6 @@ contract P2PSwap is StakingServiceUtils {
         return marketCount;
     }
 
-    //◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢
-    // Tools for Evvm
-    //◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢
-
-    function makePay(
-        address _user_Evvm,
-        address _token_Evvm,
-        uint256 _nonce_Evvm,
-        uint256 _ammount_Evvm,
-        uint256 _priorityFee_Evvm,
-        bool _priority_Evvm,
-        bytes memory _signature_Evvm
-    ) internal {
-        Evvm(evvmAddress).pay(
-            _user_Evvm,
-            address(this),
-            "",
-            _token_Evvm,
-            _ammount_Evvm,
-            _priorityFee_Evvm,
-            _nonce_Evvm,
-            _priority_Evvm,
-            address(this),
-            _signature_Evvm
-        );
-    }
-
-    function makeCaPay(
-        address _user_Evvm,
-        address _token_Evvm,
-        uint256 _ammount_Evvm
-    ) internal {
-        Evvm(evvmAddress).caPay(_user_Evvm, _token_Evvm, _ammount_Evvm);
-    }
-
-    function makeDisperseCaPay(
-        EvvmStructs.DisperseCaPayMetadata[] memory toData,
-        address token,
-        uint256 amount
-    ) internal {
-        Evvm(evvmAddress).disperseCaPay(toData, token, amount);
-    }
-
     //◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢
     // Admin tools
     //◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢◤◢
@@ -825,7 +719,7 @@ contract P2PSwap is StakingServiceUtils {
     function stake(uint256 amount) external {
         if (
             msg.sender != owner ||
-            amount * Staking(stakingAddress).priceOfStaking() >
+            amount * staking.priceOfStaking() >
             balancesOfContract[0x0000000000000000000000000000000000000001]
         ) revert();
 
@@ -922,13 +816,6 @@ contract P2PSwap is StakingServiceUtils {
         return markets;
     }
 
-    function checkIfANonceP2PSwapIsUsed(
-        address user,
-        uint256 nonce
-    ) public view returns (bool) {
-        return nonceP2PSwap[user][nonce];
-    }
-
     function getBalanceOfContract(
         address token
     ) external view returns (uint256) {