Contract Address Details

// File: contracts/Initializable.sol


pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {


    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
    * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        // solhint-disable-next-line no-inline-assembly
        assembly {cs := extcodesize(self)}
        return cs == 0;
    }
}

// File: contracts/interfaces/IOwnable.sol


pragma solidity ^0.8.0;

interface IOwnable {
    function owner() external view returns (address);
}

// File: contracts/Ownable.sol


pragma solidity ^0.8.0;



/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
* @author crypto-pumpkin
*
* By initialization, the owner account will be the one that called initializeOwner. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Initializable {

    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(){
        initializeOwner();
    }

    /**
    * @dev COVER : Initializes the contract setting the deployer as the initial owner.
    */
    function initializeOwner() internal initializer {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
         * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == msg.sender, "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/Delegated.sol


pragma solidity ^0.8.0;

/**
 * Copyright (C) 2018, 2019, 2020 Ethernity HODL UG
 *
 * This file is part of ETHERNITY PoX SC.
 *
 * ETHERNITY PoE SC is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */


contract Delegated is Ownable {
    address public callerAddress;

    event ProxyTransferred(address indexed _from, address indexed _to);

    /*constructor() {
        callerAddress = msg.sender;
    }*/

    modifier onlyDelegate {
        require(msg.sender == callerAddress);
        _;
    }

    function transferProxy(address _newProxy) public onlyOwner {
        callerAddress = _newProxy;
    }
}

// File: contracts/CompanyWallet.sol


pragma solidity ^0.8.0;


contract CompanyWallet is Ownable {
    mapping(address => bool) companyAddresses;

    constructor(){
        companyAddresses[msg.sender] = true;
    }

    function addCompanyWallet(address companyAddress) public onlyOwner {
        companyAddresses[companyAddress] = true;
    }

    function removeCompanyWallet(address oldCompanyAddress) public onlyOwner {
        companyAddresses[oldCompanyAddress] = false;
    }

    /**
     * @dev Throws if called by any account other than other of company wallets.
     */
    modifier onlyCompanyWallet() {
        require(
            companyAddresses[msg.sender],
            "CompanyWallet: caller is not a wallet from company"
        );
        _;
    }
}

// File: contracts/Enums.sol


pragma solidity ^0.8.0;

library Enums {
    enum BaseStakeStatus {
        PENDING,
        APPROVED,
        DECLINED,
        CANCELED,
        TERMINATED
    }

    enum ExtendedStakeStatus {
        PENDING,
        APPROVED,
        DECLINED,
        CANCELED,
        TERMINATED
    }

    enum StakeContractStatus {
        PENDING,
        APPROVED,
        DECLINED,
        CANCELED,
        TERMINATED
    }

    enum EntityType{
        STAKER,
        NODE_OPERATOR
    }

    enum StakeType{
        BASE_STAKE,
        EXTENDED_STAKE
    }
}

// File: contracts/Models.sol


pragma solidity ^0.8.0;


library Models {
    struct BaseStake {
        address stakeHolderAddress;
        address rewardAddress;
        address nodeAddress;
        uint256 timestamp;
        uint64 amount;
        uint16 period;
        Enums.BaseStakeStatus status;
        uint256 stakeContractId;
    }

    struct ExtendedStake {
        address stakeHolderAddress;
        address rewardAddress;
        address nodeAddress;
        uint256 timestamp;
        uint64 amount;
        uint64 amountBooked;
        uint64 stakingContracts;
        uint16 period; // in months
        uint8 operatorRewardPercentage;
        bool allowMultipleOp;
        bool autoConfirm;
        Enums.ExtendedStakeStatus status;

        mapping(uint64 => uint256) stakingContractsMapping;
        mapping(Enums.StakeContractStatus => uint64) stakingContractsStatuses;
    }

    struct StakeContract {
        address stakeHolder;
        address stakeRewardAddress;
        address nodeAddress;
        address nodeRewardAddress;
        uint256 timestamp;
        uint64 amount;
        uint64 operatorRewardPercentage;
        uint16 period; //in months
        uint256 canceledOn;
        uint256 approvedOn;
        uint256 expiresOn;
        Enums.StakeContractStatus status;
        uint256 stakeId;
        Enums.StakeType stakeType;
        bool isOperatorPerformingBad;
    }
}

// File: contracts/EtnyStakingStorage.sol

pragma solidity ^0.8.0;


/**
 * Copyright (C) 2018, 2019, 2020 Ethernity HODL UG
 *
 * This file is part of ETHERNITY PoX SC.
 *
 * ETHERNITY PoE SC is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */




contract EtnyStakingStorage is Delegated, CompanyWallet {

    constructor() {
        _owner = msg.sender;
        companyAddresses[msg.sender] = true;
    }

    address public implementation;
    address[] internal versions;

    address public _owner;
    address internal _etnyPartnershipProgramSmartContractAddress;
    address internal _etnyTokenSmartContractAddress;
    address internal _etnyNFTIntegrationContractAddress;

    // contracts and requests lists
    Models.BaseStake[] internal _baseStakesList;
    Models.ExtendedStake[] internal _extendedStakeList;
    Models.StakeContract[] internal _stakingContractsList;

    mapping(address => uint256[]) internal _stakerBaseStakeRequests;
    mapping(address => uint256[]) internal _stakerExtendedStakeRequests;

    mapping(address => uint256[]) internal _nodeBaseStakeRequests;
    mapping(address => bool) internal _nodeActiveBaseStake;
    mapping(address => uint256[]) internal _nodeExtendedStakeRequests;
    mapping(address => uint256[]) internal _nodeExtendedContracts;

    mapping(address => uint256) internal _nodeStakingTotal;
    mapping(uint256 => uint256) internal _baseStakePenalty;

    mapping(address => uint256) internal _tokensLockedInStaking;
    mapping(address => bool) internal _canceledBaseStakeNodes;

    //technical properties
    uint256 maxTokens = 75000;
    uint256 maxNFTTokens = 225000;
    uint8 apyPercentage = 10;
    uint8 minPeriodStakeContractInMonths = 6;
    uint64 totalSupply = 15000000;
    uint64 minBaseStakeAmount = 1976;
    uint64 minBaseStakeNFTAmount = 700;
    uint64 minExtendedStakeAmount = 3024;
    uint64 maxBaseStakeAmount = 75000;
    uint64 nodesStakeMinAmount = 5000;
}

// File: contracts/EtnyStakingRegistry.sol


pragma solidity ^0.8.0;

/**
 * Copyright (C) 2018, 2019, 2020 Ethernity HODL UG
 *
 * This file is part of ETHERNITY PoX SC.
 *
 * ETHERNITY PoE SC is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */


contract EtnyStakingRegistry is EtnyStakingStorage {

    constructor() {
        versions.push(address(0));
    }


    /**
    * @dev Upgrades the implementation address
    * @param _newImplementation address of the new implementation
    */
    function upgradeTo(address _newImplementation) public onlyOwner returns (bool success){

        require(implementation != _newImplementation,
            "EthernityStakingRegistry: new implementation should be different than older one.");
        _setImplementation(_newImplementation);
        return true;
    }


    // User interface //
    function _delegate(address _implementation) internal virtual {

        assembly {

            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize())
            let result := delegatecall(gas(), _implementation, ptr, calldatasize(), 0, 0)
            let size := returndatasize()
            returndatacopy(ptr, 0, size)

            switch result
            case 0 {
                revert(ptr, size)
            }
            default {
                return (ptr, size)
            }
        }
    }

    function _fallback() private {
        address target = implementation;
        require(target != address(0));
        callerAddress = msg.sender;

        _delegate(target);
    }

    fallback() external payable {
        _fallback();
    }

    receive() external payable {
        _fallback();
    }

    /**
    * @dev Sets the address of the current implementation
    * @param _newImp address of the new implementation
    */
    function _setImplementation(address _newImp) internal onlyOwner {
        implementation = _newImp;
        versions.push(_newImp);
    }

}