0x20cb79ef5d3a9072e156eb3db8961d1c464f0957

//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

interface IDesolexERC20 {
    function balanceOf(address account) external view returns (uint256 balance);
    function transfer(address recipient, uint256 amount) external returns (bool success);
}

contract DesolexContract {
    address public constant miners = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8);
    address public constant reserve = address(0x15e1e0a94fdf1cac0f8fb374e5b37031c6565809);
    address public constant token = address(0x5fec2b4e19d9c76f26182aba81dafcb9facdba94);
    
    address public owner; // STORAGE[0x0]
    address public pendingOwner; // STORAGE[0x1]
    uint256 public accQuantuPerHashrate; // STORAGE[0x2]
    uint256 public accEthPerHashrate; // STORAGE[0x3]
    uint256 public lastUpdateTime; // STORAGE[0x4]
    uint256 public pendingEthPool; // STORAGE[0x5]
    mapping(address => uint256) public quantuDebt; // STORAGE[0x6]
    mapping(address => uint256) public ethDebt; // STORAGE[0x7]
    mapping(address => uint256) public pendingQuantu; // STORAGE[0x8]
    mapping(address => uint256) public pendingEth; // STORAGE[0x9]
    
    event EmergencyWithdrawal(address indexed, address indexed, uint256);
    error NotMiners();
    event Claimed(address indexed, uint256, uint256);
    event Settled(address indexed, uint256, uint256);
    error OwnableUnauthorizedAccount(address);
    event EthRewardsDeposited(address indexed, uint256);
    error EthTransferFailed();
    event OwnershipTransferStarted(address indexed, address indexed);
    error ZeroAddress();
    event OwnershipTransferred(address indexed, address indexed);
    
    modifier onlyOwner() {
        require(msg.sender == owner, OwnableUnauthorizedAccount());
        _;
    }
    
    function claim() public {
        internal_921(msg.sender);
        (bool success0, bytes memory returnData0) = address(0x5fec2b4e19d9c76f26182aba81dafcb9facdba94).balanceOf(address(this)); // staticcall
        require(success0);
        uint256 accountBalance = abi.decode(returnData0, (uint256));
        uint256 value2 = pendingQuantu[msg.sender];
        if (!(pendingQuantu[msg.sender] < accountBalance)) {
            value2 = accountBalance;
        }
        uint256 value3 = pendingEth[msg.sender];
        if (pendingEth[msg.sender] < address(this).balance) {
        } else {
            value3 = address(this).balance;
        }
        pendingQuantu[msg.sender] = pendingQuantu[msg.sender] - value2;
        pendingEth[msg.sender] = pendingEth[msg.sender] - value3;
        if (value2 != 0x0) {
            (bool success1, bytes memory returnData1) = address(0x5fec2b4e19d9c76f26182aba81dafcb9facdba94).transfer(msg.sender, value2); // call
            require(success1);
            bool transferSucceeded = abi.decode(returnData1, (bool));
            require(transferSucceeded, "quantu transfer failed");
        }
        if (value3 != 0x0) {
            (bool success2, bytes memory returnData2) = address(msg.sender).call{ value: value3 }(""); // call
            uint256 value4 = 0x60;
            if (returnData2.length != 0) {
                var_b = var_b + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                value4 = var_b;
            }
            require(success2, EthTransferFailed());
        }
        emit Claimed(msg.sender, value2, value3);
    }
    
    function emergencyWithdraw(address token, uint256 arg1, address recipient) public {
        internal_685(recipient, arg1, token);
    }
    
    function settle(address newAddress) public {
        internal_921(newAddress);
    }
    
    function renounceOwnership() public onlyOwner {
        pendingOwner = address(0);
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
    
    function acceptOwnership() public {
        require(msg.sender == pendingOwner, OwnableUnauthorizedAccount());
        pendingOwner = address(0);
        emit OwnershipTransferred(owner, msg.sender);
        owner = msg.sender;
    }
    
    function depositEthRewards() public payable {
        pendingEthPool = msg.value + pendingEthPool;
        emit EthRewardsDeposited(msg.sender, msg.value);
    }
    
    function rebase(address arg0) public {
        internal_c20(arg0);
    }
    
    function transferOwnership(address newOwner) public onlyOwner {
        pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner, pendingOwner);
    }
    
    function internal_921(address arg0) private {
        // Decompilation incomplete: helper effect provenance is conservative.
        lastUpdateTime = block.timestamp;
        (bool success0, bytes memory returnData0) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).totalHashrate(); // staticcall
        require(success0);
        uint256 var_b;
        var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((var_b + returnData0.length) - var_b >= 0x20);
        if (0 - var_d != 0) {
            if (0x15e1e0a94fdf1cac0f8fb374e5b37031c6565809 != 0) {
                (bool success1, bytes memory returnData1) = address(0x15e1e0a94fdf1cac0f8fb374e5b37031c6565809).pull(); // call
                require(success1);
                var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                require((var_b + returnData1.length) - var_b >= 0x20);
                if (var_d != 0x0) {
                    accQuantuPerHashrate = ((0x0de0b6b3a7640000 * var_d) / var_d) + accQuantuPerHashrate;
                }
                if (pendingEthPool == 0) {
                    (bool success2, bytes memory returnData2) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
                    require(success2);
                    var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                    require((var_b + returnData2.length) - var_b >= 0x20);
                    if (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0] != 0) {
                        pendingQuantu[arg0] = (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0]) + pendingQuantu[arg0];
                    }
                    if (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0] != 0) {
                        pendingEth[arg0] = (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]) + pendingEth[arg0];
                    }
                    quantuDebt[arg0] = (accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
                    ethDebt[arg0] = (accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
                    if ((accQuantuPerHashrate * value2 / 0xde0b6b3a7640000 - quantuDebt[arg0] != 0x0) || (accEthPerHashrate * value2 / 0xde0b6b3a7640000 - ethDebt[arg0] > 0x0)) {
                        emit Settled(arg0, ((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0], ((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]);
                    }
                } else {
                    accEthPerHashrate = ((0x0de0b6b3a7640000 * pendingEthPool) / var_d) + accEthPerHashrate;
                    pendingEthPool = 0;
                    (bool success3, bytes memory returnData3) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
                    require(success3);
                    var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                    require((var_b + returnData3.length) - var_b >= 0x20);
                    if (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0] != 0) {
                        pendingQuantu[arg0] = (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0]) + pendingQuantu[arg0];
                    }
                    if (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0] != 0) {
                        pendingEth[arg0] = (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]) + pendingEth[arg0];
                    }
                    quantuDebt[arg0] = (accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
                    ethDebt[arg0] = (accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
                    if ((accQuantuPerHashrate * value3 / 0xde0b6b3a7640000 - quantuDebt[arg0] != 0x0) || (accEthPerHashrate * value3 / 0xde0b6b3a7640000 - ethDebt[arg0] > 0x0)) {
                        emit Settled(arg0, ((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0], ((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]);
                    }
                }
            }
            if (0 != 0) {
                accQuantuPerHashrate = (((0x0de0b6b3a7640000 * 0) / var_d) + accQuantuPerHashrate);
            }
            if (pendingEthPool != 0x0) {
                accEthPerHashrate = (((0x0de0b6b3a7640000 * pendingEthPool) / var_d) + accEthPerHashrate);
                pendingEthPool = 0;
            }
        }
        (bool success4, bytes memory returnData4) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
        require(success4);
        var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require(!(((var_b + returnData4.length) - var_b) < 0x20));
        if (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0] != 0) {
            pendingQuantu[arg0] = (((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0]) + pendingQuantu[arg0];
        }
        if (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0] != 0) {
            pendingEth[arg0] = (((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]) + pendingEth[arg0];
        }
        quantuDebt[arg0] = (accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
        ethDebt[arg0] = (accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
        if ((accQuantuPerHashrate * value4 / 0xde0b6b3a7640000 - quantuDebt[arg0] != 0x0) || (accEthPerHashrate * value4 / 0xde0b6b3a7640000 - ethDebt[arg0] > 0x0)) {
            emit Settled(arg0, ((accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - quantuDebt[arg0], ((accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000) - ethDebt[arg0]);
        }
    }
    
    function internal_685(address arg0, uint256 arg1, address arg2) private {
        // Decompilation incomplete: helper effect provenance is conservative.
        require(msg.sender == owner, OwnableUnauthorizedAccount());
        require(arg0 != address(0), ZeroAddress());
        if (arg2 != address(0)) {
            uint256 accountBalance = IDesolexERC20(arg2).balanceOf(address(this));
            uint256 value0 = accountBalance;
            if (arg1 != 0x0) {
                value0 = arg1;
            }
            bool transferSucceeded = IDesolexERC20(arg2).transfer(arg0, value0);
            require(transferSucceeded, "transfer failed");
            emit EmergencyWithdrawal(arg2, arg0, value0);
            return;
        } else {
            uint256 value1 = address(this).balance;
            if (arg1 != 0x0) {
                value1 = arg1;
            }
            (bool success2, bytes memory returnData2) = arg0.call{ value: value1 }(""); // call
            uint256 value2 = 0x60;
            if (returnData2.length != 0) {
                uint256 var_c;
                var_c = var_c + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                value2 = var_c;
            }
            require(success2, EthTransferFailed());
            emit EmergencyWithdrawal(arg2, arg0, value1);
            return;
        }
    }
    
    function internal_c20(address arg0) private {
        // Decompilation incomplete: helper effect provenance is conservative.
        require(address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8) == msg.sender, NotMiners());
        lastUpdateTime = block.timestamp;
        (bool success0, bytes memory returnData0) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).totalHashrate(); // staticcall
        require(success0);
        uint256 var_b;
        var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((var_b + returnData0.length) - var_b >= 0x20);
        if (0 - var_d != 0) {
            if (0x15e1e0a94fdf1cac0f8fb374e5b37031c6565809 != 0) {
                (bool success1, bytes memory returnData1) = address(0x15e1e0a94fdf1cac0f8fb374e5b37031c6565809).pull(); // call
                require(success1);
                var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                require((var_b + returnData1.length) - var_b >= 0x20);
                if (var_d != 0x0) {
                    accQuantuPerHashrate = ((0x0de0b6b3a7640000 * var_d) / var_d) + accQuantuPerHashrate;
                }
                if (pendingEthPool == 0) {
                    address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
                } else {
                    accEthPerHashrate = ((0x0de0b6b3a7640000 * pendingEthPool) / var_d) + accEthPerHashrate;
                    pendingEthPool = 0;
                    address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
                }
                require(success1);
                var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
                require((var_b + returnData1.length) - var_b >= 0x20);
                quantuDebt[arg0] = (accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
                ethDebt[arg0] = (accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
            }
            if (0 != 0) {
                accQuantuPerHashrate = (((0x0de0b6b3a7640000 * 0) / var_d) + accQuantuPerHashrate);
            }
            if (pendingEthPool != 0x0) {
                accEthPerHashrate = (((0x0de0b6b3a7640000 * pendingEthPool) / var_d) + accEthPerHashrate);
                pendingEthPool = 0;
            }
        }
        (bool success4, bytes memory returnData4) = address(0x9923cc42bc32a41bb5ec23890f7fa10cfecb32e8).playerHashrate(arg0); // staticcall
        require(success4);
        var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require(!(((var_b + returnData4.length) - var_b) < 0x20));
        quantuDebt[arg0] = (accQuantuPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
        ethDebt[arg0] = (accEthPerHashrate * var_b.length) / 0x0de0b6b3a7640000;
    }
    
    // Note: This selector table is synthetic and is not part of the original Solidity source.
    // It records the recovered selector-to-signature mapping without executable behavior.
    
    // 0x077f3561 => accEthPerHashrate()
    // 0x26ae96ce => quantuDebt(address)
    // 0x2a9a8628 => pendingEthPool()
    // 0x48e6e392 => ethDebt(address)
    // 0x4e71d92d => claim()
    // 0x551512de => emergencyWithdraw(address,uint256,address)
    // 0x5ee0aca0 => miners()
    // 0x6a256b29 => settle(address)
    // 0x715018a6 => renounceOwnership()
    // 0x79ba5097 => acceptOwnership()
    // 0x8da5cb5b => owner()
    // 0xb3ac27bf => depositEthRewards()
    // 0xbeae30f5 => pendingEth(address)
    // 0xc8f33c91 => lastUpdateTime()
    // 0xcd3293de => reserve()
    // 0xd0df1374 => rebase(address)
    // 0xe30c3978 => pendingOwner()
    // 0xe650e016 => pendingQuantu(address)
    // 0xe91c2b27 => accQuantuPerHashrate()
    // 0xf2fde38b => transferOwnership(address)
    // 0xfc0c546a => token()
}