contract/Mining.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import "./Base.sol";

contract A_Mining is Ownable, Base {
    address        private _thisAddress;
    address        private _sendAwardAddress;
    address        private _lpAddress;
    address        private _usdtAddress;
    address        private _okcAddress;
    address        private _marketingAddress;
    IUniswapV2Pair private _lPToken;
    IERC20         private _usdtToken;
    IERC20         private _okcToken;
    uint256        private userId;
    uint256        private randKey;

    struct User {
        uint256 userId;
        uint256 code;
        uint256 regTime;
    }

    struct StakeOrderInfo {
        address sender;
        uint256 amount;
        uint256 lPAmount;
        uint256 receiveAmount;
        uint256 status;
    }

    struct UnStakeOrderInfo {
        address sender;
        uint256 stakeOrderId;
    }

    struct ReceiveOrderInfo {
        address sender;
        uint256 stakeOrderId;
        uint256 amount;
    }

    mapping (address => User) private user;
    mapping (uint256 => StakeOrderInfo)   private stakeOrder;
    mapping (uint256 => UnStakeOrderInfo) private unStakeOrderInfo;
    mapping (uint256 => ReceiveOrderInfo) private receiveOrderInfo;

    constructor() {
        _thisAddress      = address(this);
        //_sendAwardAddress = address(0xA12CC19e68741327b9AD03D3cb6BD0B4e8Dd2a9B);    //发放奖励钱包地址
        _marketingAddress = address(0x8A5eA893a78b7248eC14e980b5568496A0baBA03);    //营销地址
        _okcAddress       = address(0xF8d6D3Ae255094FA7db192956A4B2A3F5bd8e6e6);
        _lpAddress        = address(0xf73D5c07624EA2AE3E8245eaE6A1D98767e1A488);
        _usdtAddress      = address(0x55d398326f99059fF775485246999027B3197955);

        /*_marketingAddress = address(0x831fb743F7CB4Cbde0B3fd6B75FC972FD29da7A3);    //营销地址
        _okcAddress       = address(0xc8328808813B66B34eD485f1ED56DB74943dDa80);
        _lpAddress        = address(0xb8717a3BA362dbB0CFa36aF23B4eB771e9a085f1);
        _usdtAddress      = address(0xf1D777aa525643a707916DDE263c694EA93996aD);*/
        
        _lPToken          = IUniswapV2Pair(_lpAddress);
        _usdtToken        = IERC20(_usdtAddress);
        _okcToken         = IERC20(_okcAddress);
    }

    function getUserCode() view public returns(uint256) {
        return user[msg.sender].code;
    }

    function getCode(address sender) view public onlyOwner returns(uint256) {
        return user[sender].code;
    }

    event RegisterEvent(uint256 userId, uint256 userCode);
    function register() public {
        address sender = msg.sender;
        require(user[sender].userId == 0, "Account already exists");
        userId++;
        user[sender].userId = userId;
        user[sender].code = uint(keccak256(abi.encode(sender, block.timestamp, block.number, userId, randKey))) % 1000000000;
        randKey = user[sender].code;
        emit RegisterEvent(userId, user[sender].code);
    }

    event StakeEvent(uint256 orderId, address sender, uint256 amount, uint256 lpAmount);
    function stake(uint256 orderId, uint256 amount) public {
        require(stakeOrder[orderId].amount == 0, "Order number already exists");
        
        uint256 lPAmount = getUsdtToLp(amount * 100 * 1e18);
        address sender = _msgSender();
        stakeOrder[orderId].sender   = sender;
        stakeOrder[orderId].amount   = amount;
        stakeOrder[orderId].lPAmount = lPAmount;
        _lPToken.transferFrom(sender, _thisAddress, lPAmount);
        emit StakeEvent(orderId, sender, amount, lPAmount);
    }

    event UnStakeEvent(uint256 orderId, address sender, uint256 stakeOrderId, uint256 lPAmount);
    function unstake(uint256 orderId, uint256 stakeOrderId) public {
        require(unStakeOrderInfo[orderId].stakeOrderId == 0, "Order Id number already exists");
        require(stakeOrder[stakeOrderId].amount > 0, "Stake Order Id number does not exist");
        require(stakeOrder[stakeOrderId].status == 0, "The order has been unpacked");
        address sender = _msgSender();
        require(stakeOrder[stakeOrderId].sender == sender, "error");
        
        uint256 lPAmount = getStakeLpAmount(stakeOrderId);
        _lPToken.approve(_thisAddress, lPAmount);
        _lPToken.transferFrom(_thisAddress, sender, lPAmount);
        unStakeOrderInfo[orderId].sender       = sender;
        unStakeOrderInfo[orderId].stakeOrderId = stakeOrderId;
        stakeOrder[stakeOrderId].status = 1;
        emit UnStakeEvent(orderId, sender, stakeOrderId, lPAmount);
    }

    event GiveReceive(uint256 orderId, address sender, uint256 stakeOrderId, uint256 amount);
    function giveReceive(uint256 orderId, address sender, uint256 stakeOrderId, uint256 amount) public onlyOwner {
        require(receiveOrderInfo[orderId].stakeOrderId == 0, "Order Id number already exists");
        require(stakeOrder[stakeOrderId].amount > 0, "Stake Order Id number does not exist");
        
        uint256 destoryAmount   = getProportion(amount, 3);
        uint256 marketingAmount = getProportion(amount, 2);
        _okcToken.approve(_thisAddress, amount);
        _okcToken.transferFrom(_thisAddress, address(0x000000000000000000000000000000000000dEaD), destoryAmount);
        _okcToken.transferFrom(_thisAddress, _marketingAddress, marketingAmount);
        _okcToken.transferFrom(_thisAddress, sender, amount - destoryAmount - marketingAmount);
        receiveOrderInfo[orderId].stakeOrderId = stakeOrderId;
        receiveOrderInfo[orderId].amount       = amount;
        receiveOrderInfo[orderId].sender       = sender;
        stakeOrder[stakeOrderId].receiveAmount += amount;
        emit GiveReceive(orderId, sender, stakeOrderId, amount);
    }

    function getStakeLpAmount(uint256 orderId) view public returns(uint256) {
        return stakeOrder[orderId].lPAmount;
    }

    function checkReceiveOrder(uint256 orderId, uint256 stakeOrderId, uint256 amount, address sender) view public returns(uint256) {
        if (receiveOrderInfo[orderId].amount == amount && receiveOrderInfo[orderId].sender == sender && receiveOrderInfo[orderId].stakeOrderId == stakeOrderId) {
            return 1;
        }
        return 0;
    }

    function checkStakeOrder(uint256 orderId, uint256 amount, address sender) view public returns(uint256) {
        if (stakeOrder[orderId].amount == amount && stakeOrder[orderId].sender == sender) {
            return 1;
        }
        return 0;
    }

    function checkUnStakeOrder(uint256 orderId, uint256 stakeOrderId, address sender) view public returns(uint256) {
        if (unStakeOrderInfo[orderId].stakeOrderId == stakeOrderId && unStakeOrderInfo[orderId].sender == sender) {
            return 1;
        }
        return 0;
    }

    function getUsdtToLp(uint256 amount) view public returns(uint256) {
        uint256 total_lp   = _lPToken.totalSupply();
        uint256 total_Usdt = _usdtToken.balanceOf(_lpAddress);
        return (total_lp * 1e18 / total_Usdt) * amount / 1e18;
        //return (amount / (total_Usdt * 1e18 / total_lp)) * 1e18;
    }

    function getUsdtToOkc(uint256 amount) view public returns(uint256) {
        (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(_lpAddress).getReserves();
        address token0 = IUniswapV2Pair(_lpAddress).token0();

        uint256 usdtBalance = 0;
        uint256 thisBalance = 0;
        if(_okcAddress == token0) {
            usdtBalance = reserve1;
            thisBalance = reserve0;
        }
        else {
            usdtBalance = reserve0;
            thisBalance = reserve1;
        }

        return ((thisBalance * 1e18 / usdtBalance) * amount) / 1e18;
    }

    function getProportion(uint256 amount, uint per) private pure returns(uint256) {
        return (amount * per) / 100;
    }
}