// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

pragma solidity ^0.7.3;

/**
 * @title Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function totalSupply() external view returns (uint256);

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
}

// SPDX-License-Identifier: No License

pragma solidity ^0.7.3;

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

/**
 * @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@github
 *
 * 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  {
    address public _owner;

    event OwnershipTransferInitiated(address indexed previousOwner, address indexed newOwner);
    event OwnershipTransferCompleted(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev COVER: Initializes the contract setting the deployer as the initial owner.
     */
    function initializeOwner() public  {
        require(_owner == address(0));
        _owner = msg.sender;
        emit OwnershipTransferCompleted(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 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 OwnershipTransferInitiated(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

pragma solidity ^0.7.3;
pragma experimental ABIEncoderV2;
import "./Ownable.sol";
import './IERC20.sol';
import './SafeMath.sol';
import "./SafeERC20.sol";

/*
 * 上币 合约 
*/
contract ieoCoinContract is  Ownable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    uint    public priceDecimals;      
    uint256 public registerAmount;
    uint8   private TOKEN_DECIMALS; 
    uint8    private PRICE_DECIMALS;
    IERC20 public COIN;
    IERC20 public MINI;
    

    
    uint256     private fee;
    uint256     private feeBase;
    uint        applyCoinId;
    address     public daoAddress;
    uint256     public registeFee;
    constructor(IERC20 _MINI )public{
        initializeOwner();
        MINI            = _MINI;
        priceDecimals   = 4;
        TOKEN_DECIMALS  = 18;
        PRICE_DECIMALS  = 6;
        registerAmount  = 1 * (10 ** uint256(TOKEN_DECIMALS));
        fee             = 5;
        feeBase         = 1000;
        applyCoinId     = 1;
        addapplyCoin(msg.sender ,"ETH",18);          
        registeFee      = 0;
        _owner = msg.sender;
        
    }
    struct ieoCoinInfoHead{
        address     coinAddress;         
        string      symbol;              
        uint        decimals;               
        uint        collectType;            
        uint256     ieoAmount;                
        uint256     price;               
        bool        bBuyLimit;           
        uint256     uBuyLimitNumber;     
        bool        bPartner;           
        uint256     partnerNumber;       
        bool        bDAO;                
        uint256     uDAONumber;          
        uint        openType;            
        uint        blockNumber;         
        uint        openTime;            

        bool        bDEX;                    
        uint256     uDexNumber;         
        uint256     poolCoinAmount;      
        bool        usdtType;
    }
    struct ieoCoinInfo{
        ieoCoinInfoHead ieoCoinHead; 
        uint        uTimestamp;          
        address     coinId;
        uint256     ieoAmountTotal;      
        uint256     registerAmount;      
        uint256     collectAmount;       

        uint256     allCollectAmount;    
        
        uint256     ieoAmountComplete;   

        uint256     daoCollectAmount;   //DAO里面预留的币 1:ETH  2:USDT  3:MINI 数量
        uint256     dexCollectAmount;   //DEX里面预留的币 1:ETH  2:USDT  3:MINI 数量

        bool        bExpired;           
        uint        buyNonce;           
        bool        bTop;                
        address     createUserAddress;   
        bool        bPayDAO;
        uint256     txid;
        bool        UsdtType;   
    }
    event CreateIeoCoin(address user,address coinAddress,uint time,uint256 txid,uint256 amount);
    event BuyCoin(address user,uint256 amount,address applyAddress, uint256 makeCoinAmount,uint256 txid);
    event TakeOut(address user,uint256 amount,uint collectType ) ;
    event Withdraw(address user,IERC20 COIN,uint256 amount ,address coinId,uint256 txid);
    event SetIeoCoinDao(address coinId,address daoAddress,uint256 amount);
    event AddLiquidity(address user,address coinid,uint256 balance,uint256 txid);
    event TakeOutFee(address user,uint256 amount);

    mapping(address=>ieoCoinInfo) ieoCoin;                  
    struct userInfo{
        uint        uTimestamp;          
        address     coinAddress;         
        uint256     makeCoinAmount;      
        uint256     takeCoinAmount;      
        address     userAddress;
    }
    mapping(address=> mapping(address=> userInfo)) usercoin;
    struct applyCoinInfo{
        uint        uTimestamp;
        address     contractAddress;
        string      symbol;
        uint        decimals;
    }
    mapping(address => applyCoinInfo) applyCoin;
    mapping(uint => address) applyCoinAddress;
 
    
    uint [] applyCoinList;
    function setUsdtType(address coinid,bool _UsdtType) public onlyOwner returns(bool){
        require(coinid != address(0));
        ieoCoin[coinid].UsdtType = _UsdtType;
        return true;
    }
    function getapplyCoinListLenght() public view returns(uint){
        return applyCoinList.length;
    }
    function getapplyCoinListData(uint index) public view returns(uint){
        require(applyCoinList.length > index);
        return applyCoinList[index];
    }
    function getapplyCoinAddress(uint coinid) public view returns(address){
        return applyCoinAddress[coinid];
    }
    function getapplyCoin(address contractAddress) public view returns(applyCoinInfo memory){
        return applyCoin[contractAddress];
    }
    function addapplyCoin(address contractAddress,string memory symbol,uint decimals) public onlyOwner returns(bool){
        require(applyCoin[contractAddress].contractAddress == address(0));   
        applyCoinInfo memory newapplyCoinInfo = applyCoinInfo({
            uTimestamp:         block.timestamp,
            contractAddress:    contractAddress,
            symbol:             symbol,
            decimals:           decimals                   
        });
        applyCoin[contractAddress] = newapplyCoinInfo;
        applyCoinList.push(applyCoinId);
        applyCoinAddress[applyCoinId] = contractAddress;
        applyCoinId++;
        return true;
    }
   
 
    function getfee() public view returns(uint){
        return fee;
    }
 
    function setfee(uint _fee) public onlyOwner returns(bool){
        require(_fee>=0);
        fee = _fee;
        return true;
    }
 
    function getUserInfo(address userAddress,address coinId) public view returns(userInfo memory){
        return usercoin[userAddress][coinId];
    }
    function getieoCoin( address id ) public view returns(ieoCoinInfo memory){
        require( id != address(0) );           
        return ieoCoin[id];
    }
    function getregisterAmount() public view  returns(uint256){
        return registerAmount;
    }
    function setregisterAmount(uint256 amount) public onlyOwner returns(bool){
        require(amount>=0);
        registerAmount = amount;
        return true;
    }
    function createIeoCoin(ieoCoinInfoHead memory ieoCoinHead,uint256 txid) public payable returns(bool){
        require(ieoCoinHead.coinAddress != address(0));
        require(ieoCoinHead.ieoAmount > 0);
        address coinId = ieoCoinHead.coinAddress;
        require(ieoCoin[coinId].ieoCoinHead.coinAddress == address(0));  
        require(msg.value >=  registerAmount );                          
        ieoCoinInfo memory newieoCoinInfo = ieoCoinInfo({
            ieoCoinHead:            ieoCoinHead,
            uTimestamp:             block.timestamp,
            coinId:                 coinId,
            ieoAmountTotal:         (ieoCoin[coinId].ieoAmountTotal).add(ieoCoinHead.ieoAmount), 
            registerAmount:         msg.value,
            collectAmount:          0,
            allCollectAmount:       0,
            ieoAmountComplete:      0,
            daoCollectAmount:       0,
            dexCollectAmount:       0,
            bExpired:               false,
            buyNonce:               0,
            bTop:                   false,
            createUserAddress:      msg.sender,
            bPayDAO:                false,
            txid:                   txid,
            UsdtType:               ieoCoinHead.usdtType
            
        });
        
        ieoCoin[coinId]  = newieoCoinInfo;        
        ieoCoin[coinId].coinId = coinId;

        ieoCoin[coinId].ieoCoinHead.poolCoinAmount = (ieoCoin[coinId].ieoCoinHead.ieoAmount).mul(ieoCoin[coinId].ieoCoinHead.uDexNumber);
        ieoCoin[coinId].ieoCoinHead.poolCoinAmount = (ieoCoin[coinId].ieoCoinHead.poolCoinAmount).div(100);

        uint256 amount = ieoCoinHead.ieoAmount.add( ieoCoin[coinId].ieoCoinHead.poolCoinAmount );
        COIN =  IERC20(ieoCoinHead.coinAddress) ;
        COIN.safeTransferFrom(msg.sender, address(this), amount);
        
        registeFee = registeFee.add(msg.value);
        emit CreateIeoCoin(msg.sender,ieoCoinHead.coinAddress,block.timestamp,txid,amount);      
        return true;
    }
    function checkBuyStatus(address coinid) private returns(bool){
        bool bStatus = false;
        if(block.number > ieoCoin[coinid].ieoCoinHead.blockNumber ){
            uint num = (block.number).sub( ieoCoin[coinid].ieoCoinHead.blockNumber ) ;
            if( num.mul(15)  > ieoCoin[coinid].ieoCoinHead.openTime ){
               bStatus = true;
            }
            else{
                bStatus = false;
            }
        }
        else{
            bStatus = false;
        }
        return bStatus;
    }
    function buyCoin(address coinid,uint256 amount) public payable returns(bool){
        require(ieoCoin[coinid].bExpired == false);        
        require(ieoCoin[coinid].ieoCoinHead.ieoAmount >= ieoCoin[coinid].ieoAmountComplete );   

        require(ieoCoin[coinid].ieoCoinHead.coinAddress != address(0));

        require(checkBuyStatus(coinid) == false ) ;           
        
        
        address applyAddress = applyCoinAddress[ieoCoin[coinid].ieoCoinHead.collectType];
        uint decimals = applyCoin[applyAddress].decimals;              
        uint to_decimals = ieoCoin[coinid].ieoCoinHead.decimals;                                  
        
        uint256 makeCoinAmount;                   
        makeCoinAmount = (amount.mul(10 ** to_decimals)).div(10 ** decimals);

        makeCoinAmount = makeCoinAmount.mul( ieoCoin[coinid].ieoCoinHead.price );
        
        makeCoinAmount = makeCoinAmount.div(10 ** uint256(PRICE_DECIMALS));
        
        require(ieoCoin[coinid].ieoCoinHead.ieoAmount >= makeCoinAmount.add(ieoCoin[coinid].ieoAmountComplete)  );

        address APPLYCOIN  = applyCoin[applyAddress].contractAddress ; 

       
        if( ieoCoin[coinid].ieoCoinHead.bBuyLimit ){
            require(usercoin[msg.sender][coinid].takeCoinAmount <= ieoCoin[coinid].ieoCoinHead.uBuyLimitNumber);
        }
  
        if( ieoCoin[coinid].ieoCoinHead.bPartner ){
            require(MINI.balanceOf(msg.sender) >= ieoCoin[coinid].ieoCoinHead.partnerNumber);
        }
        uint256 feeAmount;    
        if(ieoCoin[coinid].ieoCoinHead.collectType == 1){                                        
            require(msg.value >= amount );  
            feeAmount =   amount.mul(fee).div(feeBase);
            address payable myOwner = address(uint160(_owner));
            myOwner.transfer(feeAmount);                        
        }
        else{
            require(IERC20(APPLYCOIN).balanceOf(msg.sender) >= amount);
            feeAmount =   amount.mul(fee).div(feeBase);  
            
            IERC20(APPLYCOIN).safeTransferFrom(msg.sender, address(this), amount.sub(feeAmount));      
            IERC20(APPLYCOIN).safeTransferFrom(msg.sender, _owner, feeAmount);        
        }
    
        ieoCoin[coinid].collectAmount = (amount.sub(feeAmount)).add(ieoCoin[coinid].collectAmount);      
        ieoCoin[coinid].allCollectAmount = ieoCoin[coinid].collectAmount;
        ieoCoin[coinid].ieoAmountComplete = makeCoinAmount.add(ieoCoin[coinid].ieoAmountComplete);            
        setDaoAndDexCollect(coinid);
        ieoCoin[coinid].buyNonce ++;

        userInfo memory newuserinfo = userInfo({
            uTimestamp:         block.timestamp,
            coinAddress:        coinid,
            makeCoinAmount:     makeCoinAmount.add(usercoin[msg.sender][coinid].makeCoinAmount),   
            takeCoinAmount:     amount.add(usercoin[msg.sender][coinid].takeCoinAmount),          
            userAddress:        msg.sender
        });
        usercoin[msg.sender][coinid] = newuserinfo;
        uint256 txid = ieoCoin[coinid].txid;
        emit BuyCoin(msg.sender,amount,APPLYCOIN,makeCoinAmount,txid);        
        return true;
    }  
    function setDaoAndDexCollect(address coinid) private returns(bool){
        uint256 collectAmount = ieoCoin[coinid].collectAmount;
        uint256 daocollectAmount = collectAmount.mul(ieoCoin[coinid].ieoCoinHead.uDAONumber);
        daocollectAmount = daocollectAmount.div( 100 );
        ieoCoin[coinid].daoCollectAmount = daocollectAmount;

        uint256 dexCollectAmount = collectAmount.mul(ieoCoin[coinid].ieoCoinHead.uDexNumber);
        dexCollectAmount = dexCollectAmount.div(100);
        ieoCoin[coinid].dexCollectAmount = dexCollectAmount;
        return true;
    }
    function takeOut(address coinid) public returns(bool){
        require(ieoCoin[coinid].collectAmount >= 0);                      
        require(ieoCoin[coinid].createUserAddress == msg.sender );            

        require(checkBuyStatus(coinid) == true); 

        uint256 collectAmount = ieoCoin[coinid].collectAmount;
        address applyAddress = applyCoinAddress[ieoCoin[coinid].ieoCoinHead.collectType];
        
        address APPLYCOIN  = applyCoin[applyAddress].contractAddress ;     
        ieoCoin[coinid].collectAmount = 0;
        if( ieoCoin[coinid].ieoCoinHead.bDAO ){
            collectAmount = collectAmount.sub(ieoCoin[coinid].daoCollectAmount);
            ieoCoin[coinid].collectAmount = collectAmount ;         
        }
        if( ieoCoin[coinid].ieoCoinHead.bDEX ){
            collectAmount = collectAmount.sub(ieoCoin[coinid].dexCollectAmount);
            ieoCoin[coinid].collectAmount = collectAmount;
        }
        if( collectAmount > 0 ){
            if( ieoCoin[coinid].ieoCoinHead.collectType == 1 ){
                address payable createUserAddress = address(uint160(ieoCoin[coinid].createUserAddress));
                createUserAddress.transfer(collectAmount); 
            }
            else{
                IERC20(APPLYCOIN).safeTransfer(msg.sender,collectAmount);    
            }
        }
       
        ieoCoin[coinid].collectAmount = 0;
        ieoCoin[coinid].bExpired = true;

        uint256 balance = (ieoCoin[coinid].ieoCoinHead.ieoAmount).sub(ieoCoin[coinid].ieoAmountComplete) ;
        //add dex
        uint decimals = applyCoin[applyAddress].decimals;
        uint to_decimals = ieoCoin[coinid].ieoCoinHead.decimals;

        uint256  dexCoinAmount =  ieoCoin[coinid].dexCollectAmount;
        dexCoinAmount = (dexCoinAmount.mul(10 ** to_decimals)).div(10 ** decimals);     
        dexCoinAmount = dexCoinAmount.mul(ieoCoin[coinid].ieoCoinHead.price);          
        dexCoinAmount = dexCoinAmount.div(10 ** uint256(PRICE_DECIMALS));
        
        balance = balance.add( (ieoCoin[coinid].ieoCoinHead.poolCoinAmount).sub(dexCoinAmount) ) ;
        COIN = IERC20(ieoCoin[coinid].ieoCoinHead.coinAddress); 
        COIN.safeTransfer(msg.sender, balance); 
        emit TakeOut(msg.sender,ieoCoin[coinid].collectAmount,ieoCoin[coinid].ieoCoinHead.collectType);
        return true;
    } 
    
    function withdraw(address coinid,uint256 amount) public returns(bool){
        require(msg.sender != address(0));
        require(usercoin[msg.sender][coinid].makeCoinAmount > 0);

        require(usercoin[msg.sender][coinid].userAddress == msg.sender);
        require(usercoin[msg.sender][coinid].makeCoinAmount >= amount);
        usercoin[msg.sender][coinid].makeCoinAmount = (usercoin[msg.sender][coinid].makeCoinAmount).sub(amount);
        COIN = IERC20(ieoCoin[coinid].ieoCoinHead.coinAddress);   
        COIN.safeTransfer(msg.sender,amount );          
        emit Withdraw(msg.sender,COIN, amount,coinid,ieoCoin[coinid].txid );
        return true;
    }
    function getieoUserInfo(address user,address coinid) public view returns(uint256,uint256){
        require(user != address(0));
        require(ieoCoin[coinid].ieoCoinHead.coinAddress != address(0));
        uint256 makeCoinAmount = usercoin[user][coinid].makeCoinAmount;
        uint256 takeCoinAmount = usercoin[user][coinid].takeCoinAmount;
        return (makeCoinAmount,takeCoinAmount);
    }
    function getieoCoinSallInfo(address coinid) public view returns(uint256,uint256){
        require(ieoCoin[coinid].ieoCoinHead.coinAddress != address(0));
        uint256 buyNonce = ieoCoin[coinid].buyNonce;
        uint256 ieoAmountComplete = ieoCoin[coinid].ieoAmountComplete;
        return (buyNonce,ieoAmountComplete);
    }
    function getieoCoinInfoByDao(address coinid) public view returns(address,bool,uint256,uint256,address,bool){
        require(ieoCoin[coinid].ieoCoinHead.coinAddress != address(0));
        bool    bDAO                = ieoCoin[coinid].ieoCoinHead.bDAO;
        uint256 uDAONumber          = ieoCoin[coinid].ieoCoinHead.uDAONumber;
        uint256 daoCollectAmount    = ieoCoin[coinid].daoCollectAmount;
        address contractAddress     = ieoCoin[coinid].ieoCoinHead.coinAddress;
        address createAddress       = ieoCoin[coinid].createUserAddress; 
        bool    bExpired            = ieoCoin[coinid].bExpired;
        return(contractAddress,bDAO,uDAONumber,daoCollectAmount,createAddress,bExpired);        
    }
    function getieoCoinInfoByDex(address coinId) public view returns(address,bool,uint256,uint256,address){
        require(ieoCoin[coinId].ieoCoinHead.coinAddress != address(0));
        bool    bDEX                = ieoCoin[coinId].ieoCoinHead.bDEX;
        uint256 uDexNumber          = ieoCoin[coinId].ieoCoinHead.uDexNumber;
        uint256 dexCollectAmount    = ieoCoin[coinId].dexCollectAmount;        
        address contractAddress     = ieoCoin[coinId].ieoCoinHead.coinAddress;
        address createUserAddress   = ieoCoin[coinId].createUserAddress;
        return(contractAddress,bDEX,uDexNumber,dexCollectAmount,createUserAddress);        
    }
    function setdaoAddress(address _address) public onlyOwner returns(bool){
        require(_address != address(0));
        daoAddress = _address;
        return true;
    }
    function setIeoCoinDao(address coinId,uint256 amount,uint256 uDAONumber) public  returns(bool){
        require(msg.sender == daoAddress);  //only daoieo run
        require(ieoCoin[coinId].daoCollectAmount > 0);
        require(ieoCoin[coinId].daoCollectAmount >= amount );

        address applyAddress = applyCoinAddress[ieoCoin[coinId].ieoCoinHead.collectType];
        address APPLYCOIN  = applyCoin[applyAddress].contractAddress ;      //get apply address
        if( ieoCoin[coinId].ieoCoinHead.bDAO ){
            ieoCoin[coinId].bPayDAO = true;
            ieoCoin[coinId].ieoCoinHead.uDAONumber = uDAONumber;
            ieoCoin[coinId].daoCollectAmount = (ieoCoin[coinId].daoCollectAmount).sub(amount);          
        }
        if( ieoCoin[coinId].daoCollectAmount == 0 ){
            ieoCoin[coinId].bExpired = true;
        }
        if( ieoCoin[coinId].ieoCoinHead.collectType == 1 ){
            address payable createUserAddress = address(uint160(ieoCoin[coinId].createUserAddress));
            createUserAddress.transfer(amount); 
        }
        else{
            IERC20(APPLYCOIN).safeTransfer((ieoCoin[coinId].createUserAddress),amount);  
        } 
        emit SetIeoCoinDao(coinId,daoAddress,amount);
        return true;
    }
    function addLiquidity(address coinid) public onlyOwner returns(bool){
        require(checkBuyStatus(coinid) == true); 
        require(ieoCoin[coinid].dexCollectAmount > 0);

        uint256 dexCollectAmount = ieoCoin[coinid].dexCollectAmount;
        address applyAddress = applyCoinAddress[ieoCoin[coinid].ieoCoinHead.collectType];        
        address APPLYCOIN  = applyCoin[applyAddress].contractAddress ;      
        if( ieoCoin[coinid].ieoCoinHead.bDEX ){
            ieoCoin[coinid].dexCollectAmount = 0 ;
        }
        if( ieoCoin[coinid].ieoCoinHead.collectType == 1 ){
            address payable myOwner = address(uint160(_owner));
            myOwner.transfer(dexCollectAmount); 
        }
        else{
            IERC20(APPLYCOIN).safeTransfer(_owner,dexCollectAmount);    
        } 
        uint decimals = applyCoin[applyAddress].decimals;
        uint to_decimals = ieoCoin[coinid].ieoCoinHead.decimals;

        
        uint256 balance = (dexCollectAmount.mul(10 ** to_decimals)).div(10 ** decimals);
        balance = balance.mul(ieoCoin[coinid].ieoCoinHead.price) ;
        balance = balance.div(10 ** uint256(PRICE_DECIMALS));
        COIN = IERC20(ieoCoin[coinid].ieoCoinHead.coinAddress);
        COIN.safeTransfer(_owner, balance);
        emit AddLiquidity(msg.sender,coinid,balance,ieoCoin[coinid].txid);
        return true;
    }
    function takeOutFee() public onlyOwner returns(bool){
        require(registeFee > 0);
        msg.sender.transfer(registeFee);
        emit TakeOutFee(msg.sender,registeFee);
        registeFee = 0 ;
        return true;
    }
    function getregisteFee() public view returns(uint256) {
        return registeFee;
    }
    function getCoinType(address coinid) public view returns(bool){
        require(coinid != address(0));
        return ieoCoin[coinid].UsdtType; 
    }
 }

{
  "compilationTarget": {
    "localhost/ieo.sol": "ieoCoinContract"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}