@evvm/testnet-contracts 3.0.0 → 3.0.2

package/contracts/core/Core.sol

@@ -88,9 +88,9 @@ contract Core is Storage {
 
         admin.current = _initialOwner;
 
-        balances[_stakingContractAddress][evvmMetadata.principalTokenAddress] =
-            getRewardAmount() *
-            2;
+        rewardFlowDistribution.flag = true;
+
+        _giveReward(_stakingContractAddress, 2);
 
         stakerList[_stakingContractAddress] = FLAG_IS_STAKER;
 
@@ -114,9 +114,9 @@ contract Core is Storage {
             revert Error.AddressCantBeZero();
 
         nameServiceAddress = _nameServiceAddress;
-        balances[nameServiceAddress][evvmMetadata.principalTokenAddress] =
-            10000 *
-            10 ** 18;
+
+        _giveReward(_nameServiceAddress, 20);
+
         stakerList[nameServiceAddress] = FLAG_IS_STAKER;
 
         treasuryAddress = _treasuryAddress;
@@ -182,6 +182,8 @@ contract Core is Storage {
         }
     }
 
+    //░▒▓█ Testnet Functions ██████████████████████████████████████████████████████▓▒░
+
     /**
      * @notice Faucet: Adds balance to a user for testing (Testnet only).
      * @param user Recipient address.
@@ -194,6 +196,9 @@ contract Core is Storage {
         uint256 quantity
     ) external {
         balances[user][token] += quantity;
+
+        if (token == evvmMetadata.principalTokenAddress)
+            currentSupply += quantity;
     }
 
     /**
@@ -254,7 +259,7 @@ contract Core is Storage {
             ) != from
         ) revert Error.InvalidSignature();
 
-        if (!canExecuteUserTransaction(from))
+        if (!_canExecuteUserTransaction(from))
             revert Error.UserCannotExecuteTransaction();
 
         if (isAsyncExec) {
@@ -288,9 +293,9 @@ contract Core is Storage {
         _updateBalance(from, to, token, amount);
 
         if (isAddressStaker(msg.sender)) {
-            if (priorityFee > 0) {
+            if (priorityFee > 0)
                 _updateBalance(from, msg.sender, token, priorityFee);
-            }
+
             _giveReward(msg.sender, 1);
         }
     }
@@ -332,7 +337,7 @@ contract Core is Storage {
                     payment.signature
                 ) !=
                 payment.from ||
-                !canExecuteUserTransaction(payment.from)
+                !_canExecuteUserTransaction(payment.from)
             ) {
                 results[iteration] = false;
                 continue;
@@ -367,6 +372,14 @@ contract Core is Storage {
                 }
             }
 
+            if (
+                (listStatus.current == 0x01 && !allowList[payment.token]) ||
+                (listStatus.current == 0x02 && denyList[payment.token])
+            ) {
+                results[iteration] = false;
+                continue;
+            }
+
             if (
                 (payment.senderExecutor != address(0) &&
                     msg.sender != payment.senderExecutor) ||
@@ -450,7 +463,7 @@ contract Core is Storage {
             ) != from
         ) revert Error.InvalidSignature();
 
-        if (!canExecuteUserTransaction(from))
+        if (!_canExecuteUserTransaction(from))
             revert Error.UserCannotExecuteTransaction();
 
         if (isAsyncExec) {
@@ -480,6 +493,8 @@ contract Core is Storage {
         if (balances[from][token] < amount + (isSenderStaker ? priorityFee : 0))
             revert Error.InsufficientBalance();
 
+        if (listStatus.current != 0x00) _verifyTokenInteractionAllowance(token);
+
         uint256 acomulatedAmount = 0;
         balances[from][token] -= (amount + (isSenderStaker ? priorityFee : 0));
         address to_aux;
@@ -546,6 +561,8 @@ contract Core is Storage {
         address token,
         uint256 amount
     ) external {
+        if (listStatus.current != 0x00) _verifyTokenInteractionAllowance(token);
+
         address from = msg.sender;
 
         if (!CAUtils.verifyIfCA(from)) revert Error.NotAnCA();
@@ -608,7 +625,7 @@ contract Core is Storage {
         if (originExecutor != address(0) && tx.origin != originExecutor)
             revert Error.OriginIsNotTheOriginExecutor();
 
-        if (!canExecuteUserTransaction(user))
+        if (!_canExecuteUserTransaction(user))
             revert Error.UserCannotExecuteTransaction();
 
         if (isAsyncExec) {
@@ -688,17 +705,15 @@ contract Core is Storage {
      * - Canceling pending service operations
      * - Correcting accidental reservations
      * - Freeing nonces for different services
-     *
-     * @param user Address that reserved the nonce
      * @param nonce The async nonce to revoke reservation for
      */
-    function revokeAsyncNonce(address user, uint256 nonce) external {
-        if (asyncNonce[user][nonce]) revert Error.AsyncNonceAlreadyUsed();
+    function revokeAsyncNonce(uint256 nonce) external {
+        if (asyncNonce[msg.sender][nonce]) revert Error.AsyncNonceAlreadyUsed();
 
-        if (asyncNonceReservedPointers[user][nonce] == address(0))
+        if (asyncNonceReservedPointers[msg.sender][nonce] == address(0))
             revert Error.AsyncNonceNotReserved();
 
-        asyncNonceReservedPointers[user][nonce] = address(0);
+        asyncNonceReservedPointers[msg.sender][nonce] = address(0);
     }
 
     //░▒▓█ UserValidator Management Functions █████████████████████████████████████▓▒░
@@ -764,7 +779,7 @@ contract Core is Storage {
      */
     function acceptUserValidatorProposal() external onlyAdmin {
         if (block.timestamp < userValidatorAddress.timeToAccept)
-            revert Error.ProposalForUserValidatorNotReady();
+            revert Error.ProposalNotReadyToAccept();
 
         userValidatorAddress.current = userValidatorAddress.proposal;
         userValidatorAddress.proposal = address(0);
@@ -806,6 +821,8 @@ contract Core is Storage {
         address token,
         uint256 amount
     ) external {
+        if (listStatus.current != 0x00) _verifyTokenInteractionAllowance(token);
+
         if (msg.sender != treasuryAddress) revert Error.SenderIsNotTreasury();
 
         balances[user][token] += amount;
@@ -830,6 +847,113 @@ contract Core is Storage {
 
     //░▒▓█ Administrative Functions ████████████████████████████████████████████████████████▓▒░
 
+    //██ Total Supply Management ████████████████████████████████████████
+
+    function proposeDeleteTotalSupply() external onlyAdmin {
+        if (
+            currentSupply < (evvmMetadata.totalSupply * 9999) / 10000 ||
+            evvmMetadata.totalSupply == type(uint256).max
+        ) revert Error.MaxSupplyDeletionNotAllowed();
+
+        timeToDeleteMaxSupply = block.timestamp + TIME_TO_ACCEPT_PROPOSAL;
+    }
+
+    function rejectDeleteTotalSupply() external onlyAdmin {
+        timeToDeleteMaxSupply = 0;
+    }
+
+    function acceptDeleteTotalSupply() external onlyAdmin {
+        if (block.timestamp < timeToDeleteMaxSupply)
+            revert Error.ProposalNotReadyToAccept();
+
+        evvmMetadata.totalSupply = type(uint256).max;
+    }
+
+    //██ Reward distribution ████████████████████████████████████████
+
+    function proposeChangeBaseRewardAmount(
+        uint256 newBaseReward
+    ) external onlyAdmin {
+        if (
+            evvmMetadata.totalSupply != type(uint256).max ||
+            newBaseReward >= evvmMetadata.reward
+        ) revert Error.BaseRewardIncreaseNotAllowed();
+        proposalChangeReward = newBaseReward;
+        timeToAcceptChangeReward = block.timestamp + TIME_TO_ACCEPT_PROPOSAL;
+    }
+
+    function rejectChangeBaseRewardAmount() external onlyAdmin {
+        proposalChangeReward = 0;
+        timeToAcceptChangeReward = 0;
+    }
+
+    function acceptChangeBaseRewardAmount() external onlyAdmin {
+        if (block.timestamp < timeToAcceptChangeReward)
+            revert Error.ProposalNotReadyToAccept();
+
+        evvmMetadata.reward = proposalChangeReward;
+        proposalChangeReward = 0;
+        timeToAcceptChangeReward = 0;
+    }
+
+    function proposeChangeRewardFlowDistribution() external onlyAdmin {
+        if (currentSupply < (evvmMetadata.totalSupply * 9999) / 10000)
+            revert Error.RewardFlowDistributionChangeNotAllowed();
+
+        rewardFlowDistribution.timeToAccept =
+            block.timestamp +
+            TIME_TO_ACCEPT_PROPOSAL;
+    }
+
+    function rejectChangeRewardFlowDistribution() external onlyAdmin {
+        rewardFlowDistribution.timeToAccept = 0;
+    }
+
+    function acceptChangeRewardFlowDistribution() external onlyAdmin {
+        if (block.timestamp < rewardFlowDistribution.timeToAccept)
+            revert Error.ProposalNotReadyToAccept();
+
+        rewardFlowDistribution.flag = !rewardFlowDistribution.flag;
+        rewardFlowDistribution.timeToAccept = 0;
+    }
+
+    //██ List state Management ████████████████████████████████████████
+
+    function proposeListStatus(bytes1 newStatus) external onlyAdmin {
+        if (uint8(newStatus) >= uint8(0x03)) revert Error.InvalidListStatus();
+
+        listStatus.proposal = newStatus;
+        listStatus.timeToAccept = block.timestamp + TIME_TO_ACCEPT_PROPOSAL;
+    }
+
+    function rejectListStatusProposal() external onlyAdmin {
+        listStatus.proposal = 0x00;
+        listStatus.timeToAccept = 0;
+    }
+
+    function acceptListStatusProposal() external onlyAdmin {
+        if (block.timestamp < listStatus.timeToAccept)
+            revert Error.ProposalNotReadyToAccept();
+
+        listStatus.current = listStatus.proposal;
+        listStatus.proposal = 0x00;
+        listStatus.timeToAccept = 0;
+    }
+
+    function setTokenStatusOnAllowList(
+        address token,
+        bool status
+    ) external onlyAdmin {
+        allowList[token] = status;
+    }
+
+    function setTokenStatusOnDenyList(
+        address token,
+        bool status
+    ) external onlyAdmin {
+        denyList[token] = status;
+    }
+
     //██ Proxy Management █████████████████████████████████████████████
 
     /**
@@ -857,7 +981,7 @@ contract Core is Storage {
      */
     function acceptImplementation() external onlyAdmin {
         if (block.timestamp < timeToAcceptImplementation)
-            revert Error.TimeLockNotExpired();
+            revert Error.ProposalNotReadyToAccept();
 
         currentImplementation = proposalImplementation;
         proposalImplementation = address(0);
@@ -898,7 +1022,7 @@ contract Core is Storage {
      */
     function acceptAdmin() external {
         if (block.timestamp < admin.timeToAccept)
-            revert Error.TimeLockNotExpired();
+            revert Error.ProposalNotReadyToAccept();
 
         if (msg.sender != admin.proposal)
             revert Error.SenderIsNotTheProposedAdmin();
@@ -933,42 +1057,21 @@ contract Core is Storage {
      * - Can be called by anyone when conditions are met
      */
     function recalculateReward() public {
-        if (evvmMetadata.totalSupply > evvmMetadata.eraTokens) {
+        if (
+            evvmMetadata.totalSupply > evvmMetadata.eraTokens &&
+            evvmMetadata.totalSupply != type(uint256).max
+        ) {
             evvmMetadata.eraTokens += ((evvmMetadata.totalSupply -
                 evvmMetadata.eraTokens) / 2);
             balances[msg.sender][evvmMetadata.principalTokenAddress] +=
                 evvmMetadata.reward *
-                getRandom(1, 5083);
+                _getRandom(1, 5083);
             evvmMetadata.reward = evvmMetadata.reward / 2;
         } else {
             revert();
         }
     }
 
-    /**
-     * @notice Generates a pseudo-random number within a specified range
-     * @dev Uses block timestamp and prevrandao for randomness (suitable for non-critical randomness)
-     *
-     * Randomness Source:
-     * - Combines block.timestamp and block.prevrandao
-     * - Suitable for reward bonuses and non-security-critical randomness
-     * - Not suitable for high-stakes randomness requiring true unpredictability
-     *
-     * @param min Minimum value (inclusive)
-     * @param max Maximum value (inclusive)
-     * @return Random number between min and max (inclusive)
-     */
-    function getRandom(
-        uint256 min,
-        uint256 max
-    ) internal view returns (uint256) {
-        return
-            min +
-            (uint256(
-                keccak256(abi.encodePacked(block.timestamp, block.prevrandao))
-            ) % (max - min + 1));
-    }
-
     //░▒▓█ Staking Integration Functions █████████████████████████████████████████████████▓▒░
 
     /**
@@ -1045,19 +1148,6 @@ contract Core is Storage {
         return evvmMetadata.EvvmID;
     }
 
-    /**
-     * @notice Gets the acceptance deadline for pending token whitelist proposals
-     * @dev Returns timestamp when prepared tokens can be added to whitelist
-     * @return Timestamp when pending token can be whitelisted (0 if no pending proposal)
-     */
-    function getWhitelistTokenToBeAddedDateToSet()
-        external
-        view
-        returns (uint256)
-    {
-        return whitelistTokenToBeAdded_dateToSet;
-    }
-
     /**
      * @notice Gets the current NameService contract address
      * @dev Returns the address used for identity resolution in payments
@@ -1076,18 +1166,6 @@ contract Core is Storage {
         return stakingContractAddress;
     }
 
-    /**
-     * @notice Gets the next Fisher Bridge deposit nonce for a user
-     * @dev Returns the expected nonce for the next cross-chain deposit
-     * @param user Address to check deposit nonce for
-     * @return Next Fisher Bridge deposit nonce
-     */
-    function getNextFisherDepositNonce(
-        address user
-    ) external view returns (uint256) {
-        return nextFisherDepositNonce[user];
-    }
-
     /**
      * @notice Gets the balance of a specific token for a user
      * @dev Returns the current balance stored in the EVVM system
@@ -1112,15 +1190,6 @@ contract Core is Storage {
         return stakerList[user] == FLAG_IS_STAKER;
     }
 
-    /**
-     * @notice Gets the current era token threshold for reward transitions
-     * @dev Returns the token supply threshold that triggers the next reward halving
-     * @return Current era tokens threshold
-     */
-    function getEraPrincipalToken() public view returns (uint256) {
-        return evvmMetadata.eraTokens;
-    }
-
     /**
      * @notice Gets the current Principal Token reward amount per transaction
      * @dev Returns the base reward distributed to stakers for transaction processing
@@ -1130,6 +1199,25 @@ contract Core is Storage {
         return evvmMetadata.reward;
     }
 
+    /**
+     * @notice Gets comprehensive details of the reward change proposal
+     * @dev Returns current reward, proposed reward and time-lock info
+     *
+     * @return Proposal struct with current reward, proposed reward,
+     *         and time to accept the proposal
+     */
+    function getFullDetailReward()
+        public
+        view
+        returns (ProposalStructs.UintTypeProposal memory)
+    {
+        return ProposalStructs.UintTypeProposal({
+            current: evvmMetadata.reward,
+            proposal: proposalChangeReward,
+            timeToAccept: timeToAcceptChangeReward
+        });
+    }
+
     /**
      * @notice Gets the total supply of the Principal Token
      * @dev Returns the current total supply used for era transition calculations
@@ -1139,6 +1227,14 @@ contract Core is Storage {
         return evvmMetadata.totalSupply;
     }
 
+    /**
+     * @notice Gets the current supply of the Principal Token in circulation
+     * @dev Returns the current circulating supply used for reward recalculations
+     */
+    function getCurrentSupply() public view returns (uint256) {
+        return currentSupply;
+    }
+
     /**
      * @notice Gets the current active implementation contract address
      * @dev Returns the implementation used by the proxy for delegatecalls
@@ -1149,21 +1245,23 @@ contract Core is Storage {
     }
 
     /**
-     * @notice Gets the proposed implementation contract address
-     * @dev Returns the implementation pending approval for proxy upgrade
-     * @return Address of the proposed implementation contract (zero if none)
-     */
-    function getProposalImplementation() public view returns (address) {
-        return proposalImplementation;
-    }
-
-    /**
-     * @notice Gets the acceptance deadline for the pending implementation upgrade
-     * @dev Returns timestamp when the proposed implementation can be accepted
-     * @return Timestamp when implementation upgrade can be executed (0 if no pending proposal)
+     * @notice Gets comprehensive details of the implementation upgrade proposal
+     * @dev Returns current, proposed implementation addresses and time-lock info
+     *
+     * @return Proposal struct with current implementation, proposed implementation,
+     *         and time to accept the proposal
      */
-    function getTimeToAcceptImplementation() public view returns (uint256) {
-        return timeToAcceptImplementation;
+    function getFullDetailImplementation()
+        public
+        view
+        returns (ProposalStructs.AddressTypeProposal memory)
+    {
+        return
+            ProposalStructs.AddressTypeProposal({
+                current: currentImplementation,
+                proposal: proposalImplementation,
+                timeToAccept: timeToAcceptImplementation
+            });
     }
 
     /**
@@ -1175,31 +1273,12 @@ contract Core is Storage {
         return admin.current;
     }
 
-    /**
-     * @notice Gets the proposed admin address
-     * @dev Returns the address pending approval for admin privileges
-     * @return Address of the proposed admin (zero if no pending proposal)
-     */
-    function getProposalAdmin() public view returns (address) {
-        return admin.proposal;
-    }
-
-    /**
-     * @notice Gets the acceptance deadline for the pending admin change
-     * @dev Returns timestamp when the proposed admin can accept the role
-     * @return Timestamp when admin change can be executed (0 if no pending proposal)
-     */
-    function getTimeToAcceptAdmin() public view returns (uint256) {
-        return admin.timeToAccept;
-    }
-
-    /**
-     * @notice Gets the address of the token pending whitelist approval
-     * @dev Returns the token address that can be whitelisted after time delay
-     * @return Address of the token prepared for whitelisting (zero if none)
-     */
-    function getWhitelistTokenToBeAdded() public view returns (address) {
-        return whitelistTokenToBeAdded_address;
+    function getFullDetailAdmin()
+        public
+        view
+        returns (ProposalStructs.AddressTypeProposal memory)
+    {
+        return admin;
     }
 
     /**
@@ -1288,7 +1367,7 @@ contract Core is Storage {
      * @return Proposal struct with current validator address,
      *         proposed address, and time to accept
      */
-    function getUserValidatorAddressDetails()
+    function getFullDetailUserValidator()
         public
         view
         returns (ProposalStructs.AddressTypeProposal memory)
@@ -1296,8 +1375,113 @@ contract Core is Storage {
         return userValidatorAddress;
     }
 
+    /**
+     * @notice Gets the current token list status (none, denylist, allowlist)
+     * @dev Returns byte code indicating current token restriction mode
+     *      - 0x00: No restrictions
+     *      - 0x01: Denylist active
+     *      - 0x02: Allowlist active
+     */
+    function getCurrentListStatus() public view returns (bytes1) {
+        return listStatus.current;
+    }
+
+    /**
+     * @notice Gets comprehensive token list status details
+     * @dev Returns current list status along with pending proposal info
+     */
+    function getFullDetailListStatus()
+        public
+        view
+        returns (ProposalStructs.Bytes1TypeProposal memory)
+    {
+        return listStatus;
+    }
+
+    /**
+     * @notice Checks if a token is on the allowList or denyList based on current list status
+     * @dev Returns boolean indicating if token is allowed for execution
+     *      - true if allowed
+     *      - false if denied
+     */
+    function getAllowListStatus(address token) public view returns (bool) {
+        return allowList[token];
+    }
+
+    /**
+     * @notice Checks if a token is on the denylist or allowlist based on current list status
+     * @dev Returns boolean indicating if token is restricted for execution
+     *      - true if denied
+     *      - false if allowed
+     */
+    function getDenyListStatus(address token) public view returns (bool) {
+        return denyList[token];
+    }
+
+    /**
+     * @notice Gets the current status of the reward flow distribution flag
+     * @dev Returns boolean indicating if reward distribution is active
+     *      - true if rewards are distributed to stakers
+     *      - false if rewards are disabled
+     */
+    function getRewardFlowDistributionFlag() public view returns (bool) {
+        return rewardFlowDistribution.flag;
+    }
+
+    /**
+     * @notice Gets full details of the reward flow distribution proposal
+     * @dev Returns current flag, proposed flag, and time-lock info
+     *
+     * @return Proposal struct with current flag, proposed flag, and time to accept
+     */
+    function getFullDetailRewardFlowDistribution()
+        public
+        view
+        returns (ProposalStructs.BoolTypeProposal memory)
+    {
+        return rewardFlowDistribution;
+    }
+
+    /**
+     * @notice Gets the time remaining to delete the maximum supply
+     * @dev Returns the timestamp when the max supply can be deleted
+     *
+     * @return Timestamp for max supply deletion
+     */
+    function getTimeToDeleteMaxSupply() public view returns (uint256) {
+        return timeToDeleteMaxSupply;
+    }
+
     //░▒▓█ Internal Functions █████████████████████████████████████████████████████▓▒░
 
+    /**
+     * @notice Generates a pseudo-random number within a specified range
+     * @dev Uses block timestamp and prevrandao for randomness (suitable for non-critical randomness)
+     *
+     * @param min Minimum value (inclusive)
+     * @param max Maximum value (inclusive)
+     * @return Random number between min and max (inclusive)
+     */
+    function _getRandom(
+        uint256 min,
+        uint256 max
+    ) internal view returns (uint256) {
+        uint256 randomHash = uint256(
+            keccak256(
+                abi.encodePacked(
+                    blockhash(block.number - 1),
+                    block.timestamp,
+                    block.prevrandao,
+                    msg.sender,
+                    tx.origin,
+                    gasleft()
+                )
+            )
+        );
+
+        return min + (randomHash % (max - min + 1));
+    }
+
     //██ Balance Management █████████████████████████████████████████████
 
     /**
@@ -1325,6 +1509,8 @@ contract Core is Storage {
         address token,
         uint256 value
     ) internal {
+        if (listStatus.current != 0x00) _verifyTokenInteractionAllowance(token);
+
         uint256 fromBalance = balances[from][token];
         if (fromBalance < value) revert Error.InsufficientBalance();
 
@@ -1350,20 +1536,28 @@ contract Core is Storage {
      *
      * @param user Address of the staker to receive principal token rewards
      * @param amount Number of transactions or reward multiplier
-     * @return success True if reward distribution completed successfully
      */
-    function _giveReward(address user, uint256 amount) internal returns (bool) {
-        uint256 principalReward = evvmMetadata.reward * amount;
-        uint256 userBalance = balances[user][
-            evvmMetadata.principalTokenAddress
-        ];
+    function _giveReward(address user, uint256 amount) internal {
+        if (
+            !rewardFlowDistribution.flag ||
+            currentSupply >= evvmMetadata.totalSupply
+        ) return;
 
-        balances[user][evvmMetadata.principalTokenAddress] =
-            userBalance +
-            principalReward;
+        uint256 principalReward = evvmMetadata.reward * amount;
+        balances[user][evvmMetadata.principalTokenAddress] += principalReward;
+        currentSupply += principalReward;
+    }
 
-        return (userBalance + principalReward ==
-            balances[user][evvmMetadata.principalTokenAddress]);
+    /**
+     *  @notice Internal function to check from the token allowlist/denylist
+     *         based on current list status and revert if the token is not allowed for execution
+     *  @dev Used by functions that execute transactions to enforce token restrictions
+     */
+    function _verifyTokenInteractionAllowance(address token) internal view {
+        if (
+            (listStatus.current == 0x01 && !allowList[token]) ||
+            (listStatus.current == 0x02 && denyList[token])
+        ) revert Error.TokenIsDeniedForExecution();
     }
 
     //██ User Validation █████████████████████████████████████████████
@@ -1385,7 +1579,7 @@ contract Core is Storage {
      * @param user Address to check execution permission for
      * @return True if user can execute, false if blocked
      */
-    function canExecuteUserTransaction(
+    function _canExecuteUserTransaction(
         address user
     ) internal view returns (bool) {
         if (userValidatorAddress.current == address(0)) return true;