@evvm/testnet-contracts 1.0.0

package/src/contracts/evvm/lib/ErrorsLib.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+library ErrorsLib {
+    error InvalidSignature();
+    error SenderIsNotTheExecutor();
+    error UpdateBalanceFailed();
+    error InvalidAsyncNonce();
+    error NotAnStaker();
+    error InsufficientBalance();
+    error InvalidAmount(uint256, uint256);
+    error NotAnCA();
+    error SenderIsNotTreasury();
+    error WindowToChangeEvvmIDExpired();
+}

package/src/contracts/evvm/lib/EvvmStorage.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+import {EvvmStructs} from "./EvvmStructs.sol";
+
+/**
+ * @title EvvmStorage
+ * @author jistro.eth
+ * @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.
+ *
+ * @notice This contract should not be deployed directly, it's meant to be
+ *         inherited by the implementation contracts to ensure they maintain
+ *         the same storage layout.
+ */
+
+abstract contract EvvmStorage is EvvmStructs {
+    address constant ETH_ADDRESS = address(0);
+    bytes1 constant FLAG_IS_STAKER = 0x01;
+
+    address nameServiceAddress;
+
+    address stakingContractAddress;
+
+    address treasuryAddress;
+
+    address whitelistTokenToBeAdded_address;
+    address whitelistTokenToBeAdded_pool;
+    uint256 whitelistTokenToBeAdded_dateToSet;
+
+    /**
+     * @dev The address of the implementation contract is stored
+     *      separately because of the way the proxy pattern works,
+     *      rather than in a struct.
+     */
+    address currentImplementation;
+    address proposalImplementation;
+    uint256 timeToAcceptImplementation;
+
+    uint256 windowTimeToChangeEvvmID;
+
+    EvvmMetadata evvmMetadata;
+
+    AddressTypeProposal admin;
+
+    bytes1 breakerSetupNameServiceAddress;
+
+    mapping(address => bytes1) stakerList;
+
+    mapping(address user => mapping(address token => uint256 quantity)) balances;
+
+    mapping(address user => uint256 nonce) nextSyncUsedNonce;
+
+    mapping(address user => mapping(uint256 nonce => bool isUsed)) asyncUsedNonce;
+
+    mapping(address user => uint256 nonce) nextFisherDepositNonce;
+}

package/src/contracts/evvm/lib/EvvmStructs.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title EvvmStructs
+ * @dev Library of common structures used across EVVM and its services.
+ *      This contract serves as a shared type system for the entire ecosystem,
+ *      ensuring consistency in data structures between the core EVVM and
+ *      external service contracts.
+ *
+ * @notice This contract should be inherited by both EVVM and service contracts
+ *         that need to interact with these data structures.
+ */
+
+abstract contract EvvmStructs {
+    struct PayData {
+        address from;
+        address to_address;
+        string to_identity;
+        address token;
+        uint256 amount;
+        uint256 priorityFee;
+        uint256 nonce;
+        bool priorityFlag;
+        address executor;
+        bytes signature;
+    }
+
+    struct DispersePayMetadata {
+        uint256 amount;
+        address to_address;
+        string to_identity;
+    }
+
+    struct DisperseCaPayMetadata {
+        uint256 amount;
+        address toAddress;
+    }
+    
+    struct EvvmMetadata {
+        string EvvmName;
+        uint256 EvvmID;
+        string principalTokenName;
+        string principalTokenSymbol;
+        address principalTokenAddress;
+        uint256 totalSupply;
+        uint256 eraTokens;
+        uint256 reward;
+    }
+
+    struct AddressTypeProposal {
+        address current;
+        address proposal;
+        uint256 timeToAccept;
+    }
+
+    struct UintTypeProposal {
+        uint256 current;
+        uint256 proposal;
+        uint256 timeToAccept;
+    }
+}

package/src/contracts/evvm/lib/SignatureUtils.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: EVVM-NONCOMMERCIAL-1.0
+// Full license terms available at: https://www.evvm.info/docs/EVVMNoncommercialLicense
+
+import {SignatureRecover} from "@evvm/testnet-contracts/lib/SignatureRecover.sol";
+import {AdvancedStrings} from "@evvm/testnet-contracts/lib/AdvancedStrings.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.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
+     *       verify messages, the next functions are used to verify the messages signed
+     *       by the users
+     */
+
+
+    /**
+     *  @notice This function is used to verify the message signed for the payment
+     *  @param signer user who signed the message
+     *  @param _receiverAddress address of the receiver
+     *  @param _receiverIdentity identity of the receiver
+     *
+     *  @notice if the _receiverAddress is 0x0 the function will use the _receiverIdentity
+     *
+     *  @param _token address of the token to send
+     *  @param _amount amount to send
+     *  @param _priorityFee priorityFee to send to the staking holder
+     *  @param _nonce nonce of the transaction
+     *  @param _priorityFlag if the transaction is priority or not
+     *  @param _executor the executor of the transaction
+     *  @param signature signature of the user who wants to send the message
+     *  @return true if the signature is valid
+     */
+    function verifyMessageSignedForPay(
+        uint256 evvmID,
+        address signer,
+        address _receiverAddress,
+        string memory _receiverIdentity,
+        address _token,
+        uint256 _amount,
+        uint256 _priorityFee,
+        uint256 _nonce,
+        bool _priorityFlag,
+        address _executor,
+        bytes memory signature
+    ) internal pure returns (bool) {
+        return
+            SignatureRecover.signatureVerification(
+                Strings.toString(evvmID),
+                "pay",
+                string.concat(
+                    _receiverAddress == address(0)
+                        ? _receiverIdentity
+                        : AdvancedStrings.addressToString(_receiverAddress),
+                    ",",
+                    AdvancedStrings.addressToString(_token),
+                    ",",
+                    Strings.toString(_amount),
+                    ",",
+                    Strings.toString(_priorityFee),
+                    ",",
+                    Strings.toString(_nonce),
+                    ",",
+                    _priorityFlag ? "true" : "false",
+                    ",",
+                    AdvancedStrings.addressToString(_executor)
+                ),
+                signature,
+                signer
+            );
+    }
+
+    /**
+     *  @notice This function is used to verify the message signed for the dispersePay
+     *  @param signer user who signed the message
+     *  @param hashList hash of the list of the transactions, the hash is calculated
+     *                  using sha256(abi.encode(toData))
+     *  @param _token token address to send
+     *  @param _amount amount to send
+     *  @param _priorityFee priorityFee to send to the fisher who wants to send the message
+     *  @param _nonce nonce of the transaction
+     *  @param _priorityFlag if the transaction is priority or not
+     *  @param _executor the executor of the transaction
+     *  @param signature signature of the user who wants to send the message
+     *  @return true if the signature is valid
+     */
+    function verifyMessageSignedForDispersePay(
+        uint256 evvmID,
+        address signer,
+        bytes32 hashList,
+        address _token,
+        uint256 _amount,
+        uint256 _priorityFee,
+        uint256 _nonce,
+        bool _priorityFlag,
+        address _executor,
+        bytes memory signature
+    ) internal pure returns (bool) {
+        return
+            SignatureRecover.signatureVerification(
+                Strings.toString(evvmID),
+                "dispersePay",
+                string.concat(
+                    AdvancedStrings.bytes32ToString(hashList),
+                    ",",
+                    AdvancedStrings.addressToString(_token),
+                    ",",
+                    Strings.toString(_amount),
+                    ",",
+                    Strings.toString(_priorityFee),
+                    ",",
+                    Strings.toString(_nonce),
+                    ",",
+                    _priorityFlag ? "true" : "false",
+                    ",",
+                    AdvancedStrings.addressToString(_executor)
+                ),
+                signature,
+                signer
+            );
+    }
+
+}