/**
 *Submitted for verification at Etherscan.io on 2024-04-16
*/

// SPDX-License-Identifier: none

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: buytokenETH.sol



pragma solidity ^0.8.22;



interface AggregatorV3Interface {

  function decimals() external view returns (uint);
  function description() external view returns (string memory); 
  function version() external view returns (uint);

  // getRoundData and latestRoundData should both raise "No data present"
  // if they do not have data to report, instead of returning unset values
  // which could be misinterpreted as actual reported values.
  function getRoundData(uint80 _roundId)
    external
    view
    returns (
      uint roundId,
      uint answer,
      uint startedAt,
      uint updatedAt,
      uint answeredInRound
    );
  function latestRoundData() 
    external 
    view 
    returns ( 
      uint roundId, 
      uint answer, 
      uint startedAt, 
      uint updatedAt,  
      uint answeredInRound   
    );

}
contract PriceConsumerV3 {     
 
    AggregatorV3Interface internal priceFeed;
    AggregatorV3Interface internal btcPriceFeed;
    AggregatorV3Interface internal ethPriceFeed;

 constructor() {
        priceFeed = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419); 
        btcPriceFeed = AggregatorV3Interface(0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c); 

    }

    function getThePrice() public view returns (uint) {
        (
            uint roundID, 
            uint price,  
            uint startedAt,
            uint timeStamp,
            uint answeredInRound
        ) = priceFeed.latestRoundData();
        return price;
    }

     function getThePriceBtc() public view returns (uint) {
        (
            uint roundID, 
            uint price,
            uint startedAt,
            uint timeStamp,
            uint answeredInRound
        ) = btcPriceFeed.latestRoundData();
        return price;
    }

     function getThePriceEth() public view returns (uint) {
        (
            uint roundID, 
            uint price,
            uint startedAt,
            uint timeStamp,
            uint answeredInRound
        ) = ethPriceFeed.latestRoundData();
        return price;
    }
}


interface BEP20 {
    function totalSupply() external view returns (uint theTotalSupply);
    function balanceOf(address _owner) external view returns (uint balance);
    function transfer(address _to, uint _value) external ;
    function transferFrom(address _from, address _to, uint _value) external ;
    function approve(address _spender, uint _value) external returns (bool success);
    function allowance(address _owner, address _spender) external view returns (uint remaining);
    event Transfer(address indexed _from, address indexed _to, uint _value);
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}   


interface ERC20 {
    function totalSupply() external view returns (uint theTotalSupply);
    function balanceOf(address _owner) external view returns (uint balance);
    function transfer(address _to, uint _value) external returns (bool success);
    function transferFrom(address _from, address _to, uint _value) external returns (bool success);
    function approve(address _spender, uint _value) external returns (bool success);
    function allowance(address _owner, address _spender) external view returns (uint remaining);
    event Transfer(address indexed _from, address indexed _to, uint _value);
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}   


contract CRUDO is ReentrancyGuard {  
  
   PriceConsumerV3 priceConsumerV3 = new PriceConsumerV3(); 
   uint public priceOfBNB = priceConsumerV3.getThePrice();
   uint public priceOfWbtc = priceConsumerV3.getThePriceBtc(); 
                  
                  
  struct Tariff {
    uint time;  
    uint percent;
  }
  
  struct Deposit { 
    uint tariff;
    uint amount;
    uint tokenAmount;
    uint at;
  }
  
  struct Investor {
    bool registered;
    Deposit[] deposits;
    uint invested;
    
  } 

   struct TokenPurchase {
        address buyer; 
        uint amount;
        uint timestamp;
        uint amountType ;  // 0 = bnb , 1 =token 

    }  

    TokenPurchase[] public allTokenPurchases;
 
    

  // mainnet
   address public wbtc = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;  // WBTC MainNet           
   address public usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;  //USDT Mainnet
   address public usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;  // USDC MainNet 

  uint public tokenPrice;
  uint public tokenPriceDecimal;



  event OwnershipTransferred(address);
  
  address public owner = msg.sender;
  address public owner1 = 0x4B16fc61800da83eeFF71e66465cC3c273657dA5 ;
  
  
  uint public totalInvested;
   address  payable  public   contractAddr = payable(0x4B16fc61800da83eeFF71e66465cC3c273657dA5);
  
  mapping (address => Investor) public investors;
  mapping(address => TokenPurchase[]) public tokenPurchases;
  event DepositAt(address user, uint tariff, uint amount);
  event Withdraw(address user, uint amount);
  
  constructor() {
    tokenPrice = 1;
    tokenPriceDecimal = 2;


  }

function buyTokenWithETH(address payable _to) external payable { 
    uint tariff = 0;
    require(msg.value >= 0);
    priceOfBNB = priceConsumerV3.getThePrice();
    uint tokenVal = (msg.value * priceOfBNB * 10**tokenPriceDecimal) / (tokenPrice * 100000000);
    
    if (isContract(_to)) {
        (bool success, ) = _to.call{value: msg.value}("");
        require(success, "Transfer to contract failed");
    } else {
        _to.transfer(msg.value);
    }
    
    investors[msg.sender].invested += tokenVal;
    investors[msg.sender].deposits.push(Deposit(tariff, msg.value, tokenVal, block.timestamp));
    allTokenPurchases.push(TokenPurchase(msg.sender, msg.value, block.timestamp, 0));   
    emit DepositAt(msg.sender, tariff, tokenVal);
}



function isContract(address addr) internal view returns (bool) {
    uint size;
    assembly { size := extcodesize(addr) }
    return size > 0;
}


 function buyWithToken(uint amount,uint investToken) external {
        require(investToken==1 || investToken==2 || investToken==3  , "invalid Token");

        address duductToken = usdt;
        address duductTokens = wbtc;
        uint currencyPrice = 1; 
        uint currencyPriceDecimal = 0;

        if(investToken==1){
            priceOfWbtc = priceConsumerV3.getThePriceBtc();
            currencyPrice = priceOfWbtc;
            currencyPriceDecimal = 8;
        ERC20 receiveTokens = ERC20(duductTokens);
        require(receiveTokens.balanceOf(msg.sender) >= amount, "Insufficient user balance");
        receiveTokens.transferFrom(msg.sender, contractAddr, amount);

        }

        else if(investToken==2){
         BEP20 receiveToken = BEP20(duductToken);  
         require(receiveToken.balanceOf(msg.sender) >= amount, "Insufficient user balance");
        receiveToken.transferFrom(msg.sender, contractAddr, amount);


        }
        else {
            duductTokens = usdc;
        ERC20 receiveTokens = ERC20(duductTokens);
        require(receiveTokens.balanceOf(msg.sender) >= amount, "Insufficient user balance");
        receiveTokens.transferFrom(msg.sender, contractAddr, amount);


        }

    
        
        uint tokenVal = (amount* currencyPrice* (10**tokenPriceDecimal)) / (tokenPrice * (10**currencyPriceDecimal)) ; 
        

        investors[msg.sender].invested += tokenVal;
        investors[msg.sender].deposits.push(Deposit(investToken,amount,tokenVal,block.timestamp));
        allTokenPurchases.push(TokenPurchase(msg.sender, amount, block.timestamp, investToken));   
         emit DepositAt(msg.sender, investToken, tokenVal);
  
  } 



    // Set buy price  
  function setBuyPrice(uint _price, uint _decimal) public {
    require(msg.sender == owner || msg.sender == owner1, "Only owner or owner1");
    tokenPrice = _price;
    tokenPriceDecimal = _decimal;
}
 


  function updateOwner1(address _newOwner1) public {
      require(msg.sender == owner, "Only owner can update owner1");
      owner1 = _newOwner1;
}


function updatecontractadd(address payable _newaddr) public {
   require(msg.sender == owner, "only owner can update contractadd");
   contractAddr = _newaddr; 
}



          // Owner BNB Withdraw    
    // Only owner can withdraw BNB 
      function withdrawBNB(address payable to, uint amount) public nonReentrant  returns(bool) {
        require(msg.sender == owner, "Only owner");
        require(to != address(0), "Cannot send to zero address");
        to.transfer(amount);
        return true;
    }

      function usd_price() public view returns (uint) {
      return priceOfBNB;
  }

   function tokenInBNB(uint amount) public view returns (uint) {
        uint tokenVal = (amount * priceOfBNB* 10**tokenPriceDecimal) /(tokenPrice*100000000*1000000000000000000) ;
        return (tokenVal);    
    }
  

    function tokenInBUSD(uint amount) public view returns (uint) {
        uint tokenVal = (amount * 10**tokenPriceDecimal ) /(tokenPrice*1000000000000000000) ;
        return (tokenVal);
    }

     function tokenInWbtc(uint amount) public view returns (uint) {
        uint tokenVal = (amount * priceOfWbtc* 10**tokenPriceDecimal) /(tokenPrice*100000000*1000000000000000000) ;
        return (tokenVal);
    }

    // Owner Token Withdraw    
    // Only owner can withdraw token 

    function withdrawToken(address tokenAddress, address to, uint amount) public nonReentrant  returns(bool) {
        require(msg.sender == owner, "Only owner");
        require(to != address(0), "Cannot send to zero address");
        BEP20 _token = BEP20(tokenAddress);
        _token.transfer(to, amount);
        return true;
    }


    // Ownership Transfer
    // Only owner can call this function
    function transferOwnership(address to) public returns(bool) {
        require(msg.sender == owner, "Only owner");
        require(to != address(0), "Cannot transfer ownership to zero address");
        owner = to;
        emit OwnershipTransferred(to);
        return true;
    }



        // View details
    function userDeposits(address indexAddress) public view returns (uint[] memory tariffs,uint[] memory amounts,uint[] memory getTokens, uint[] memory times) {
        uint len = investors[indexAddress].deposits.length;
        tariffs = new uint[](len);
        amounts = new uint[](len);
        getTokens = new uint[](len);
        times = new uint[](len);
        
        for(uint i = 0; i <len; i++){
            tariffs[i] = investors[indexAddress].deposits[i].tariff;
            amounts[i] = investors[indexAddress].deposits[i].amount;
            getTokens[i] = investors[indexAddress].deposits[i].tokenAmount;
            times[i] = investors[indexAddress].deposits[i].at;
            
        }
        return (tariffs, amounts, getTokens, times);
    }

    function allPrice() public view returns (uint ,uint ,uint,uint,uint,uint,uint) {
       
        return (priceOfBNB, tokenPrice, tokenPriceDecimal,priceOfWbtc,8 ,0,0);
    }   

    function getAllTokenPurchases() public view returns (TokenPurchase[] memory) {
           return allTokenPurchases;
}


}

{
  "compilationTarget": {
    "contracts/CRUDOeth.sol": "CRUDO"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}