Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// File @openzeppelin/contracts/utils/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]

// OpenZeppelin Contracts (last updated v4.7.0) (access/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.
 *
 * By default, the owner account will be the one that deploys the contract. 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.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/security/[email protected]

// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/security/[email protected]

// OpenZeppelin Contracts (last updated v4.8.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;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}


// File contracts/ETH/PresaleV1.sol

//               _    _____                                        _
// __      _____| |__|___ / _ __   __ _ _   _ _ __ ___   ___ _ __ | |_ ___
// \ \ /\ / / _ \ '_ \ |_ \| '_ \ / _` | | | | '_ ` _ \ / _ \ '_ \| __/ __|
//  \ V  V /  __/ |_) |__) | |_) | (_| | |_| | | | | | |  __/ | | | |_\__ \
//   \_/\_/ \___|_.__/____/| .__/ \__,_|\__, |_| |_| |_|\___|_| |_|\__|___/
//                         |_|          |___/
//
pragma solidity 0.8.9;
interface Aggregator {
  function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

interface StakingManager {
  function depositByPresale(address _user, uint256 _amount) external;
}

interface ISanctionsList {
  function isSanctioned(address addr) external view returns (bool);
}

contract Presale is ReentrancyGuard, Ownable, Pausable {
  // Structs for input grouping only
  struct ContractAddresses {
    address oracle;
    address usdt;
    address usdc;
  }

  struct PresaleConfig {
    uint256 startTime;
    uint256 maxTokensToBuy;
    bool dynamicTimeFlag;
    uint256 timeConstant;
  }

  // Presale config
  uint256 public startTime;
  uint256 public claimStart;
  uint256 public maxTokensToBuy;
  uint256 public baseDecimals;
  bool public dynamicTimeFlag;
  uint256 public timeConstant;

  // Token and payment tracking
  uint256 public totalTokensSold;
  uint256 public totalBoughtAndStaked;
  uint256 public usdRaised;
  address public saleToken;
  address public paymentWallet;
  address public admin;
  address public manager;

  // Round and checkpoint data
  uint256 public currentStep;
  uint256 public checkPoint;
  uint256[][3] public rounds;
  uint256[] public prevCheckpoints;
  uint256[] public remainingTokensTracker;
  uint256[] public percentages;
  address[] public wallets;

  // Interfaces
  IERC20 public USDTInterface;
  IERC20 public USDCInterface;
  Aggregator public aggregatorInterface;
  StakingManager public stakingManagerInterface;
  ISanctionsList public sanctionsList;

  // Flags and lists
  bool public applySanctions;
  bool public stakingWhitelistStatus;

  //New Variables
  address public web3PaymentWallet;
  uint256 public web3PaymentPercentage;
  uint256 public referrerPercentage;
  uint256 public initialReferrerPercentage;
  bool public referrersMustBeBuyers;
  bool public payInitialReferrers;
  uint256 public seededAmount;
  uint256 public seededUsers;

  mapping(address => uint256) public userDeposits;
  mapping(address => bool) public hasClaimed;
  mapping(address => bool) public isBlacklisted;
  mapping(address => bool) public isWhitelisted;
  mapping(address => bool) public wertWhitelisted;
  mapping(address => bool) public blacklistedReferrers;
  mapping(address => address) public initialReferrers;

  // Events
  event SaleTokenUpdated(address token);
  event SaleTimeSet(uint256 _start, uint256 timestamp);
  event SaleTimeUpdated(bytes32 indexed key, uint256 prevValue, uint256 newValue, uint256 timestamp);
  event TokensBought(address indexed user, uint256 indexed tokensBought, address indexed purchaseToken, uint256 amountPaid, uint256 usdEq, uint256 timestamp);
  event TokensAdded(address indexed token, uint256 noOfTokens, uint256 timestamp);
  event TokensClaimed(address indexed user, uint256 amount, uint256 timestamp);
  event ClaimStartUpdated(uint256 prevValue, uint256 newValue, uint256 timestamp);
  event TokensBoughtAndStaked(address indexed user, uint256 indexed tokensBought, address indexed purchaseToken, uint256 amountPaid, uint256 usdEq, uint256 timestamp);
  event TokensClaimedAndStaked(address indexed user, uint256 amount, uint256 timestamp);

  /**
   * @notice Constructor for the Presale contract.
   * @param _contracts Struct containing addresses of external contracts (oracle, USDT, USDC).
   * @param _config Struct containing configuration parameters for the presale (start/end times, max tokens, etc.).
   * @param _rounds A 3-dimensional array defining the rounds of the presale, containing price tiers or limits per round.
   */
  constructor(ContractAddresses memory _contracts, PresaleConfig memory _config, uint256[][3] memory _rounds) {
    // --- Input Validations ---
    require(_contracts.oracle != address(0), 'Zero aggregator address');
    require(_contracts.usdt != address(0), 'Zero USDT address');
    require(_contracts.usdc != address(0), 'Zero USDC address');
    require(_config.startTime > block.timestamp, 'Invalid time');

    // --- Contract Interface Initializations ---
    aggregatorInterface = Aggregator(_contracts.oracle);
    USDTInterface = IERC20(_contracts.usdt);
    USDCInterface = IERC20(_contracts.usdc);

    // --- State Variable Initializations ---
    baseDecimals = (10 ** 18);
    startTime = _config.startTime;
    rounds = _rounds;
    maxTokensToBuy = _config.maxTokensToBuy;
    paymentWallet = msg.sender;
    dynamicTimeFlag = _config.dynamicTimeFlag;
    timeConstant = _config.timeConstant;
    manager = msg.sender;

    // --- Event Emission ---
    emit SaleTimeSet(startTime, block.timestamp);
  }

  //Role Check Functions
  //Info : Used functions instead of modifiers to reduce contract size

  function _onlyManagerOrOwner() internal view {
    require(msg.sender == manager || msg.sender == owner(), 'caller not manager or owner');
  }

  function _onlyAdminOrManagerOrOwner() internal view {
    require(msg.sender == admin || msg.sender == manager || msg.sender == owner(), 'caller not admin, manager or owner');
  }

  function _onlyManager() internal view {
    require(msg.sender == manager, 'caller not manager');
  }

  /**
   * @dev To pause the presale
   */
  function pause() external {
    _onlyManagerOrOwner();
    _pause();
  }

  /**
   * @dev To unpause the presale
   */
  function unpause() external {
    _onlyManagerOrOwner();
    _unpause();
  }

  /**
   * @dev To calculate the price in USD for given amount of tokens.
   * @param _amount No of tokens
   */
  function calculatePrice(uint256 _amount) public view returns (uint256) {
    uint256 USDTAmount;
    uint256 total = checkPoint == 0 ? totalTokensSold : checkPoint;
    require(_amount <= maxTokensToBuy, 'Amount exceeds max tokens to buy');
    if (_amount + total > rounds[0][currentStep] || block.timestamp >= rounds[2][currentStep]) {
      require(currentStep < (rounds[0].length - 1), 'Wrong params');
      if (block.timestamp >= rounds[2][currentStep]) {
        require(rounds[0][currentStep] + _amount <= rounds[0][currentStep + 1], 'Cant Purchase More in individual tx');
        USDTAmount = _amount * rounds[1][currentStep + 1];
      } else {
        uint256 tokenAmountForCurrentPrice = rounds[0][currentStep] - total;
        USDTAmount = tokenAmountForCurrentPrice * rounds[1][currentStep] + (_amount - tokenAmountForCurrentPrice) * rounds[1][currentStep + 1];
      }
    } else USDTAmount = _amount * rounds[1][currentStep];
    return USDTAmount;
  }

  /**
   * @dev To update the sale times
   * @param _startTime New start time
   */
  function changeSaleTimes(uint256 _startTime) external {
    _onlyManagerOrOwner();
    require(_startTime > 0, 'Invalid parameters');
    require(block.timestamp < _startTime, 'Sale time in past');
    uint256 prevValue = startTime;
    startTime = _startTime;
    emit SaleTimeUpdated(bytes32('START'), prevValue, _startTime, block.timestamp);
  }

  /**
   * @dev To get latest ETH price in 10**18 format
   */
  function getLatestPrice() public view returns (uint256) {
    (, int256 price, , , ) = aggregatorInterface.latestRoundData();
    price = (price * (10 ** 10));
    return uint256(price);
  }

  function setSplits(address[] memory _wallets, uint256[] memory _percentages) public {
    _onlyManager();
    require(_wallets.length == _percentages.length, 'Mismatched arrays');
    delete wallets;
    delete percentages;
    uint256 totalPercentage = 0;

    for (uint256 i = 0; i < _wallets.length; i++) {
      require(_percentages[i] > 0, 'Percentage must be greater than 0');
      totalPercentage += _percentages[i];
      wallets.push(_wallets[i]);
      percentages.push(_percentages[i]);
    }

    require(totalPercentage == 100000, 'Total percentage must equal 100');
  }

  modifier checkSaleState(uint256 amount) {
    require(block.timestamp >= startTime, 'Invalid time for buying');
    require(amount > 0, 'Invalid sale amount');
    _;
  }

  /**
   * @dev To buy into a presale using USDT
   * @param amount No of tokens to buy
   * @param stake boolean flag for token staking
   * @param referrer Address of referrer, can pass zero address if no referrer
   */
  function buyWithUSDT(uint256 amount, bool stake, address referrer) external checkSaleState(amount) checkSanction(_msgSender()) whenNotPaused returns (bool) {
    uint256 usdPrice = calculatePrice(amount);
    totalTokensSold += amount;
    uint256 price = usdPrice / (10 ** 12);
    if (checkPoint != 0) checkPoint += amount;
    uint256 total = totalTokensSold > checkPoint ? totalTokensSold : checkPoint;
    if (total > rounds[0][currentStep] || block.timestamp >= rounds[2][currentStep]) {
      if (block.timestamp >= rounds[2][currentStep]) {
        checkPoint = rounds[0][currentStep] + amount;
      }
      if (dynamicTimeFlag) {
        manageTimeDiff();
      }
      uint256 unsoldTokens = total > rounds[0][currentStep] ? 0 : rounds[0][currentStep] - total - amount;
      remainingTokensTracker.push(unsoldTokens);
      currentStep += 1;
    }
    if (stake) {
      if (stakingWhitelistStatus) {
        require(isWhitelisted[_msgSender()], 'User not whitelisted for stake');
      }
      stakingManagerInterface.depositByPresale(_msgSender(), amount * baseDecimals);
      totalBoughtAndStaked += amount;
      emit TokensBoughtAndStaked(_msgSender(), amount, address(USDTInterface), price, usdPrice, block.timestamp);
    } else {
      userDeposits[_msgSender()] += (amount * baseDecimals);
      emit TokensBought(_msgSender(), amount, address(USDTInterface), price, usdPrice, block.timestamp);
    }
    usdRaised += usdPrice;
    uint256 ourAllowance = USDTInterface.allowance(_msgSender(), address(this));
    require(price <= ourAllowance, 'Make sure to add enough allowance');
    splitUSDTValue(price, referrer);

    return true;
  }

  /**
   * @dev To buy into a presale using USDC
   * @param amount No of tokens to buy
   * @param stake boolean flag for token staking
   * @param referrer Address of referrer, can pass zero address if no referrer
   */
  function buyWithUSDC(uint256 amount, bool stake, address referrer) external checkSaleState(amount) checkSanction(_msgSender()) whenNotPaused returns (bool) {
    uint256 usdPrice = calculatePrice(amount);
    totalTokensSold += amount;
    uint256 price = usdPrice / (10 ** 12);
    if (checkPoint != 0) checkPoint += amount;
    uint256 total = totalTokensSold > checkPoint ? totalTokensSold : checkPoint;
    if (total > rounds[0][currentStep] || block.timestamp >= rounds[2][currentStep]) {
      if (block.timestamp >= rounds[2][currentStep]) {
        checkPoint = rounds[0][currentStep] + amount;
      }
      if (dynamicTimeFlag) {
        manageTimeDiff();
      }
      uint256 unsoldTokens = total > rounds[0][currentStep] ? 0 : rounds[0][currentStep] - total - amount;
      remainingTokensTracker.push(unsoldTokens);
      currentStep += 1;
    }
    if (stake) {
      if (stakingWhitelistStatus) {
        require(isWhitelisted[_msgSender()], 'User not whitelisted for stake');
      }
      stakingManagerInterface.depositByPresale(_msgSender(), amount * baseDecimals);
      totalBoughtAndStaked += amount;
      emit TokensBoughtAndStaked(_msgSender(), amount, address(USDCInterface), price, usdPrice, block.timestamp);
    } else {
      userDeposits[_msgSender()] += (amount * baseDecimals);
      emit TokensBought(_msgSender(), amount, address(USDCInterface), price, usdPrice, block.timestamp);
    }
    usdRaised += usdPrice;
    uint256 ourAllowance = USDCInterface.allowance(_msgSender(), address(this));
    require(price <= ourAllowance, 'Make sure to add enough allowance');
    splitUSDCValue(price, referrer);

    return true;
  }

  /**
   * @dev To buy into a presale using ETH
   * @param amount No of tokens to buy
   * @param stake boolean flag for token staking
   * @param referrer Address of referrer, can pass zero address if no referrer
   */
  function buyWithEth(uint256 amount, bool stake, address referrer) external payable checkSaleState(amount) checkSanction(_msgSender()) whenNotPaused nonReentrant returns (bool) {
    uint256 usdPrice = calculatePrice(amount);
    uint256 ethAmount = (usdPrice * baseDecimals) / getLatestPrice();
    require(msg.value >= ethAmount, 'Less payment');
    uint256 excess = msg.value - ethAmount;
    totalTokensSold += amount;
    if (checkPoint != 0) checkPoint += amount;
    uint256 total = totalTokensSold > checkPoint ? totalTokensSold : checkPoint;
    if (total > rounds[0][currentStep] || block.timestamp >= rounds[2][currentStep]) {
      if (block.timestamp >= rounds[2][currentStep]) {
        checkPoint = rounds[0][currentStep] + amount;
      }
      if (dynamicTimeFlag) {
        manageTimeDiff();
      }
      uint256 unsoldTokens = total > rounds[0][currentStep] ? 0 : rounds[0][currentStep] - total - amount;
      remainingTokensTracker.push(unsoldTokens);
      currentStep += 1;
    }
    if (stake) {
      if (stakingWhitelistStatus) {
        require(isWhitelisted[_msgSender()], 'User not whitelisted for stake');
      }
      stakingManagerInterface.depositByPresale(_msgSender(), amount * baseDecimals);
      totalBoughtAndStaked += amount;
      emit TokensBoughtAndStaked(_msgSender(), amount, address(0), ethAmount, usdPrice, block.timestamp);
    } else {
      userDeposits[_msgSender()] += (amount * baseDecimals);
      emit TokensBought(_msgSender(), amount, address(0), ethAmount, usdPrice, block.timestamp);
    }
    usdRaised += usdPrice;
    splitETHValue(ethAmount, referrer, _msgSender());
    if (excess > 0) sendValue(payable(_msgSender()), excess);
    return true;
  }

  /**
   * @dev To buy ETH directly from wert .*wert contract address should be whitelisted if wertBuyRestrictionStatus is set true
   * @param _user address of the user
   * @param _amount No of ETH to buy
   * @param stake boolean flag for token staking
   * @param referrer Address of referrer, can pass zero address if no referrer
   */
  function buyWithETHWert(address _user, uint256 _amount, bool stake, address referrer) external payable checkSaleState(_amount) checkSanction(_user) whenNotPaused nonReentrant returns (bool) {
    require(wertWhitelisted[_msgSender()], 'User not whitelisted for this tx');
    uint256 usdPrice = calculatePrice(_amount);
    uint256 ethAmount = (usdPrice * baseDecimals) / getLatestPrice();
    require(msg.value >= ethAmount, 'Less payment');
    uint256 excess = msg.value - ethAmount;
    totalTokensSold += _amount;
    if (checkPoint != 0) checkPoint += _amount;
    uint256 total = totalTokensSold > checkPoint ? totalTokensSold : checkPoint;
    if (total > rounds[0][currentStep] || block.timestamp >= rounds[2][currentStep]) {
      if (block.timestamp >= rounds[2][currentStep]) {
        checkPoint = rounds[0][currentStep] + _amount;
      }
      if (dynamicTimeFlag) {
        manageTimeDiff();
      }
      uint256 unsoldTokens = total > rounds[0][currentStep] ? 0 : rounds[0][currentStep] - total - _amount;
      remainingTokensTracker.push(unsoldTokens);
      currentStep += 1;
    }
    if (stake) {
      if (stakingWhitelistStatus) {
        require(isWhitelisted[_user], 'User not whitelisted for stake');
      }
      stakingManagerInterface.depositByPresale(_user, _amount * baseDecimals);
      totalBoughtAndStaked += _amount;
      emit TokensBoughtAndStaked(_user, _amount, address(0), ethAmount, usdPrice, block.timestamp);
    } else {
      userDeposits[_user] += (_amount * baseDecimals);
      emit TokensBought(_user, _amount, address(0), ethAmount, usdPrice, block.timestamp);
    }
    usdRaised += usdPrice;
    splitETHValue(ethAmount, referrer, _user);
    if (excess > 0) sendValue(payable(_user), excess);
    return true;
  }

  /**
   * @dev Helper function to get ETH price for given amount
   * @param amount No of tokens to buy
   */
  function ethBuyHelper(uint256 amount) external view returns (uint256 ethAmount) {
    uint256 usdPrice = calculatePrice(amount);
    ethAmount = (usdPrice * baseDecimals) / getLatestPrice();
  }

  /**
   * @dev Helper function to get USDT price for given amount
   * @param amount No of tokens to buy
   */
  function usdtBuyHelper(uint256 amount) external view returns (uint256 usdPrice) {
    usdPrice = calculatePrice(amount);
    usdPrice = usdPrice / (10 ** 12);
  }

  function sendValue(address payable recipient, uint256 amount) internal {
    require(address(this).balance >= amount, 'Low balance');
    (bool success, ) = recipient.call{value: amount}('');
    require(success, 'ETH Payment failed');
  }

  function splitETHValue(uint256 _amount, address _referrer, address _user) internal {
    uint256 amountForWeb3PaymentWallet;
    if (web3PaymentWallet != address(0)) {
      amountForWeb3PaymentWallet = payReferrersHelper(_amount, web3PaymentWallet, web3PaymentPercentage, address(0));
    }

    uint256 amountForReferrers = payReferrers(_amount, _user, _referrer, address(0));
    _amount -= (amountForWeb3PaymentWallet + amountForReferrers);
    if (wallets.length == 0) {
      require(paymentWallet != address(0), 'Payment wallet not set');
      sendValue(payable(paymentWallet), _amount);
    } else {
      uint256 tempCalc;
      for (uint256 i = 0; i < wallets.length; i++) {
        uint256 amountToTransfer = (_amount * percentages[i]) / 100000;
        sendValue(payable(wallets[i]), amountToTransfer);
        tempCalc += amountToTransfer;
      }
      if ((_amount - tempCalc) > 0) {
        sendValue(payable(wallets[wallets.length - 1]), _amount - tempCalc);
      }
    }
  }

  function splitUSDTValue(uint256 _amount, address _referrer) internal {
    uint256 amountForWeb3PaymentWallet;
    if (web3PaymentWallet != address(0)) {
      amountForWeb3PaymentWallet = payReferrersHelper(_amount, web3PaymentWallet, web3PaymentPercentage, address(USDTInterface));
    }

    uint256 amountForReferrers = payReferrers(_amount, _msgSender(), _referrer, address(USDTInterface));
    _amount -= (amountForWeb3PaymentWallet + amountForReferrers);

    if (wallets.length == 0) {
      require(paymentWallet != address(0), 'Payment wallet not set');
      (bool success, ) = address(USDTInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), paymentWallet, _amount));
      require(success, 'Token payment failed');
    } else {
      uint256 tempCalc;
      for (uint256 i = 0; i < wallets.length; i++) {
        uint256 amountToTransfer = (_amount * percentages[i]) / 100000;
        (bool success, ) = address(USDTInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), wallets[i], amountToTransfer));
        require(success, 'Token payment failed');
        tempCalc += amountToTransfer;
      }
      if ((_amount - tempCalc) > 0) {
        (bool success, ) = address(USDTInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), wallets[wallets.length - 1], _amount - tempCalc));
        require(success, 'Token payment failed');
      }
    }
  }

  function splitUSDCValue(uint256 _amount, address _referrer) internal {
    uint256 amountForWeb3PaymentWallet;
    if (web3PaymentWallet != address(0)) {
      amountForWeb3PaymentWallet = payReferrersHelper(_amount, web3PaymentWallet, web3PaymentPercentage, address(USDCInterface));
    }

    uint256 amountForReferrers = payReferrers(_amount, _msgSender(), _referrer, address(USDCInterface));
    _amount -= (amountForWeb3PaymentWallet + amountForReferrers);

    if (wallets.length == 0) {
      require(paymentWallet != address(0), 'Payment wallet not set');
      (bool success, ) = address(USDCInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), paymentWallet, _amount));
      require(success, 'Token payment failed');
    } else {
      uint256 tempCalc;
      for (uint256 i = 0; i < wallets.length; i++) {
        uint256 amountToTransfer = (_amount * percentages[i]) / 100000;
        (bool success, ) = address(USDCInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), wallets[i], amountToTransfer));
        require(success, 'Token payment failed');
        tempCalc += amountToTransfer;
      }
      if ((_amount - tempCalc) > 0) {
        (bool success, ) = address(USDCInterface).call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), wallets[wallets.length - 1], _amount - tempCalc));
        require(success, 'Token payment failed');
      }
    }
  }

  /**
   * @dev to initialize staking manager with new address
   * @param _stakingManagerAddress address of the staking smartcontract
   */
  function setStakingManager(address _stakingManagerAddress) external {
    _onlyManagerOrOwner();
    require(_stakingManagerAddress != address(0), 'staking manager cannot be initialized with zero address');
    stakingManagerInterface = StakingManager(_stakingManagerAddress);
    IERC20(saleToken).approve(_stakingManagerAddress, type(uint256).max);
  }

  /**
   * @dev To set the claim start time and sale token address by the owner
   * @param noOfTokens no of tokens to add to the contract
   * @param _saleToken sale toke address
   */
  function startClaim(uint256 noOfTokens, address _saleToken, address _stakingManagerAddress) external returns (bool) {
    _onlyManagerOrOwner();
    require(_saleToken != address(0), 'Zero token address');
    saleToken = _saleToken;
    stakingManagerInterface = StakingManager(_stakingManagerAddress);
    IERC20(_saleToken).approve(_stakingManagerAddress, type(uint256).max);
    bool success = IERC20(_saleToken).transferFrom(_msgSender(), address(this), noOfTokens);
    require(success, 'Token transfer failed');
    emit TokensAdded(_saleToken, noOfTokens, block.timestamp);
    return true;
  }

  /**
   * @dev To set status for claim whitelisting
   * @param _status bool value
   */
  function setStakingWhitelistStatus(bool _status) external {
    _onlyManagerOrOwner();
    stakingWhitelistStatus = _status;
  }

  function setSaleToken(address _saleToken) external {
    _onlyManagerOrOwner();
    require(_saleToken != address(0), 'Zero token address');
    saleToken = _saleToken;
    emit SaleTokenUpdated(saleToken);
  }

  /**
   * @dev To change the claim start time by the owner
   * @param _claimStart new claim start time
   */
  function changeClaimStart(uint256 _claimStart) external returns (bool) {
    _onlyManagerOrOwner();
    uint256 prevValue = claimStart;
    claimStart = _claimStart;
    emit ClaimStartUpdated(prevValue, _claimStart, block.timestamp);
    return true;
  }

  /**
   * @dev To claim tokens after claiming starts
   */
  function claim() external whenNotPaused returns (bool) {
    require(saleToken != address(0), 'Sale token not added');
    require(!isBlacklisted[_msgSender()], 'This Address is Blacklisted');
    require((claimStart > 0 && block.timestamp >= claimStart) || isWhitelisted[_msgSender()], 'Claim has not started yet');
    require(!hasClaimed[_msgSender()], 'Already claimed');
    hasClaimed[_msgSender()] = true;
    uint256 amount = userDeposits[_msgSender()];
    require(amount > 0, 'Nothing to claim');
    delete userDeposits[_msgSender()];
    bool success = IERC20(saleToken).transfer(_msgSender(), amount);
    require(success, 'Token transfer failed');
    emit TokensClaimed(_msgSender(), amount, block.timestamp);
    return true;
  }

  function claimAndStake() external whenNotPaused returns (bool) {
    require(saleToken != address(0), 'Sale token not added');
    require(!isBlacklisted[_msgSender()], 'This Address is Blacklisted');
    if (stakingWhitelistStatus) {
      require(isWhitelisted[_msgSender()], 'User not whitelisted for stake');
    }
    uint256 amount = userDeposits[_msgSender()];
    require(amount > 0, 'Nothing to stake');
    totalBoughtAndStaked += amount / baseDecimals;
    stakingManagerInterface.depositByPresale(_msgSender(), amount);
    delete userDeposits[_msgSender()];
    emit TokensClaimedAndStaked(_msgSender(), amount, block.timestamp);
    return true;
  }

  /**
   * @dev To add wert contract addresses to whitelist
   * @param _whitelistStatus true for whitelisting, false to remove from whitelist
   * @param _addressesToWhitelist addresses of the contract
   */
  function whitelistUsersForWERT(bool _whitelistStatus, address[] calldata _addressesToWhitelist) external {
    _onlyManagerOrOwner();
    for (uint256 i = 0; i < _addressesToWhitelist.length; i++) {
      wertWhitelisted[_addressesToWhitelist[i]] = _whitelistStatus;
    }
  }

  function changeMaxTokensToBuy(uint256 _maxTokensToBuy) external {
    _onlyManagerOrOwner();
    require(_maxTokensToBuy > 0, 'Zero max tokens to buy value');
    maxTokensToBuy = _maxTokensToBuy;
  }

  function changeRoundsData(uint256[][3] memory _rounds) external {
    _onlyManagerOrOwner();
    rounds = _rounds;
  }

  /**
   * @dev To add users to blacklist which restricts blacklisted users from claiming
   * @param _blacklistStatus true for blacklisting, false to remove from blacklist
   * @param _usersToBlacklist addresses of the users
   */
  function blacklistUsers(bool _blacklistStatus, address[] calldata _usersToBlacklist) external {
    _onlyManagerOrOwner();
    for (uint256 i = 0; i < _usersToBlacklist.length; i++) {
      isBlacklisted[_usersToBlacklist[i]] = _blacklistStatus;
    }
  }

  /**
   * @dev To add users to whitelist which restricts users from claiming if claimWhitelistStatus is true
   * @param _whitelistStatus true for whitelisting, false to remove from whitelist
   * @param _usersToWhitelist addresses of the users
   */
  function whitelistUsers(bool _whitelistStatus, address[] calldata _usersToWhitelist) external {
    _onlyManagerOrOwner();
    for (uint256 i = 0; i < _usersToWhitelist.length; i++) {
      isWhitelisted[_usersToWhitelist[i]] = _whitelistStatus;
    }
  }

  /**
   * @dev To set payment wallet address
   * @param _newPaymentWallet new payment wallet address
   */
  function changePaymentWallet(address _newPaymentWallet) external {
    _onlyManagerOrOwner();
    require(_newPaymentWallet != address(0), 'address cannot be zero');
    paymentWallet = _newPaymentWallet;
  }

  /**
   * @dev To manage time gap between two rounds
   */
  function manageTimeDiff() internal {
    for (uint256 i; i < rounds[2].length - currentStep; i++) {
      rounds[2][currentStep + i] = block.timestamp + i * timeConstant;
    }
  }

  /**
   * @dev To set time constant for manageTimeDiff()
   * @param _timeConstant time in <days>*24*60*60 format
   */
  function setTimeConstant(uint256 _timeConstant) external {
    _onlyManagerOrOwner();
    timeConstant = _timeConstant;
  }

  /**
   * @dev To get array of round details at once
   * @param _no array index
   */
  function roundDetails(uint256 _no) external view returns (uint256[] memory) {
    return rounds[_no];
  }

  /**
   * @dev to update userDeposits for purchases made on other chains
   * @param _users array of users
   * @param _userDeposits array of userDeposits associated with users
   */
  function userSeeder(address[] calldata _users, uint256[] calldata _userDeposits) external {
    _onlyManagerOrOwner();
    require(_users.length == _userDeposits.length, 'Length mismatch');
    uint256 totalDepositsInCall = 0;
    for (uint256 i = 0; i < _users.length; i++) {
      userDeposits[_users[i]] += _userDeposits[i];
      totalDepositsInCall += _userDeposits[i];
    }
    seededUsers += _users.length;
    seededAmount += totalDepositsInCall;
  }

  /**
   * @dev To increment the rounds from backend
   */
  function incrementCurrentStep() external {
    _onlyAdminOrManagerOrOwner();
    prevCheckpoints.push(checkPoint);
    if (dynamicTimeFlag) {
      manageTimeDiff();
    }
    if (checkPoint < rounds[0][currentStep]) {
      if (currentStep == 0) {
        remainingTokensTracker.push(rounds[0][currentStep] - totalTokensSold);
      } else {
        remainingTokensTracker.push(rounds[0][currentStep] - checkPoint);
      }
      checkPoint = rounds[0][currentStep];
    }
    currentStep++;
  }

  /**
   * @dev To set admin
   * @param _admin new admin wallet address
   */
  function setAdmin(address _admin) external {
    _onlyManagerOrOwner();
    admin = _admin;
  }

  /**
   * @dev To change details of the round
   * @param _step round for which you want to change the details
   * @param _checkpoint token tracker amount
   */
  function setCurrentStep(uint256 _step, uint256 _checkpoint) external {
    _onlyManagerOrOwner();
    currentStep = _step;
    checkPoint = _checkpoint;
  }

  /**
   * @dev To set time shift functionality on/off
   * @param _dynamicTimeFlag bool value
   */
  function setDynamicTimeFlag(bool _dynamicTimeFlag) external {
    _onlyManagerOrOwner();
    dynamicTimeFlag = _dynamicTimeFlag;
  }

  /**
   * @dev     Function to return remainingTokenTracker Array
   */
  function trackRemainingTokens() external view returns (uint256[] memory) {
    return remainingTokensTracker;
  }

  /**
   * @dev     To update remainingTokensTracker Array (pass 0 to delete existing array)
   * @param   _unsoldTokens  input parameters in uint256 array format
   */
  function setRemainingTokensArray(uint256[] memory _unsoldTokens) public {
    _onlyAdminOrManagerOrOwner();
    require(_unsoldTokens.length != 0, 'cannot update invalid values');
    if (_unsoldTokens.length == 1 && _unsoldTokens[0] == 0) {
      delete remainingTokensTracker;
    } else {
      delete remainingTokensTracker;
      for (uint256 i; i < _unsoldTokens.length; i++) {
        remainingTokensTracker.push(_unsoldTokens[i]);
      }
    }
  }

  /**
   * @dev Sets the sanction details
   * @param _sanctionContract addresses of the contract
   * @param _applySanction boolean on whether the contract has to consider sanction list or not
   */
  function setSanctions(address _sanctionContract, bool _applySanction) external {
    _onlyManagerOrOwner();
    require(_sanctionContract != address(0));
    sanctionsList = ISanctionsList(_sanctionContract);
    applySanctions = _applySanction;
  }

  /**
   * @dev Checks if sanction list is enabled and if user is in sanction list, reverts the transaction.
   * @param _user addresses of the user
   */
  modifier checkSanction(address _user) {
    if (applySanctions) {
      require(!sanctionsList.isSanctioned(_user), 'Address present in sanction list');
    }
    _;
  }

  function changeManager(address _manager) external {
    _onlyManager();
    manager = _manager;
  }

  function renounceManager() external onlyOwner {
    manager = address(0);
  }

  /**
   * @dev To Update referral Details in a single go
   * @param _refereePercentage new percentage for referrals.
   * @param _initialReferrerPercentage new percentage for initial referrals.
   * @param _paymentAddress new web3 payment wallet address
   * @param _percentage new percentage.
   * @param _referrersMustBeBuyers boolean value
   * @param _payInitialReferrers boolean value
   */
  function referrerDetails(uint256 _refereePercentage, uint256 _initialReferrerPercentage, address _paymentAddress, uint256 _percentage, bool _referrersMustBeBuyers, bool _payInitialReferrers) external {
    _onlyManagerOrOwner();
    referrerPercentage = _refereePercentage;
    initialReferrerPercentage = _initialReferrerPercentage;
    web3PaymentWallet = _paymentAddress;
    web3PaymentPercentage = _percentage;
    referrersMustBeBuyers = _referrersMustBeBuyers;
    payInitialReferrers = _payInitialReferrers;
  }

  /**
   * @dev To Update referral percentage
   * @param _refereePercentage new percentage for referrals.
   * @param _initialReferrerPercentage new percentage for initial referrals.
   */
  function updateReferrerPercentage(uint256 _refereePercentage, uint256 _initialReferrerPercentage) external {
    _onlyManagerOrOwner();
    referrerPercentage = _refereePercentage;
    initialReferrerPercentage = _initialReferrerPercentage;
  }

  /**
   * @dev To Update referrers should be buyers or not for referral
   * @param _referrersMustBeBuyers boolean value
   */
  function updateReferrersMustBeBuyers(bool _referrersMustBeBuyers) external {
    _onlyManagerOrOwner();
    referrersMustBeBuyers = _referrersMustBeBuyers;
  }

  /**
   * @dev To determine if initial referees are to be paid
   * @param _payInitialReferrers boolean value
   */
  function shouldPayInitialReferrers(bool _payInitialReferrers) external {
    _onlyManagerOrOwner();
    payInitialReferrers = _payInitialReferrers;
  }

  /**
   * @dev To Update web3 payment details
   * @param _paymentAddress new web3 payment wallet address
   * @param _percentage new percentage.
   */
  function updateWeb3PaymentDetails(address _paymentAddress, uint256 _percentage) external {
    _onlyManagerOrOwner();
    web3PaymentWallet = _paymentAddress;
    web3PaymentPercentage = _percentage;
  }

  /**
   * @dev To add users to blacklisted Referral mapping
   * @param _referrers addresses of the users
   */
  function blacklistReferrer(address[] calldata _referrers) external {
    _onlyManagerOrOwner();
    uint256 referrersLen = _referrers.length;
    for (uint256 i = 0; i < referrersLen; i++) {
      blacklistedReferrers[_referrers[i]] = true;
    }
  }

  /**
   * @dev To remove users from blacklisted Referral mapping
   * @param _referrers addresses of the users
   */
  function removeFromBlacklistedReferrerMapping(address[] calldata _referrers) external {
    _onlyManagerOrOwner();
    uint256 referrersLen = _referrers.length;
    for (uint256 i = 0; i < referrersLen; i++) {
      blacklistedReferrers[_referrers[i]] = false;
    }
  }

  /**
   * @dev Returns a boolean based on referral can be applied or not
   * @param _referrer addresses of the users
   */
  function checkReferralStatus(address _referrer) public view returns (bool) {
    if (_referrer == address(0) || blacklistedReferrers[_referrer] || _referrer == _msgSender()) {
      return false;
    }

    if (!referrersMustBeBuyers) {
      return true;
    }

    return userDeposits[_referrer] > 0;
  }

  /**
   * @dev Pays referrers in USDT/ETH and returns the total amount paid.
   * @param _amount The base amount used for referral payment calculations.
   * @param _referred The address of the referred user.
   * @param _referrer The address of the referring user.
   */
  function payReferrers(uint256 _amount, address _referred, address _referrer, address _token) internal returns (uint256) {
    uint256 totalPaid;
    address referrer = getOrInsertInitialReferrer(_referred, _referrer);
    if (!checkReferralStatus(referrer)) {
      return totalPaid;
    }
    totalPaid += payReferrersHelper(_amount, referrer, referrerPercentage, _token);
    if (!payInitialReferrers) {
      return totalPaid;
    }
    address initialReferrer = getOrInsertInitialReferrer(referrer, address(0));
    if (!checkReferralStatus(initialReferrer)) {
      return totalPaid;
    }
    return (totalPaid + payReferrersHelper(_amount, initialReferrer, initialReferrerPercentage, _token));
  }

  /**
   * @dev Helper function to pay a referrer and return the amount paid.
   * @param _amount The base amount for payment calculation.
   * @param _referrer The address of the referrer.
   * @param _percentage The percentage of the base amount to pay.
   */
  function payReferrersHelper(uint256 _amount, address _referrer, uint256 _percentage, address _token) internal returns (uint256) {
    uint256 amountForReferrer = (_amount * _percentage) / 100;
    if (_token != address(0)) {
      (bool success, ) = _token.call(abi.encodeWithSignature('transferFrom(address,address,uint256)', _msgSender(), _referrer, amountForReferrer));
      require(success, 'Token payment failed');
    } else {
      sendValue(payable(_referrer), amountForReferrer);
    }

    return amountForReferrer;
  }

  /**
   * @dev Returns the initial referrer or inserts one if not present.
   * @param _referred The address of the referred user.
   * @param _referrer The address of the referrer to insert if missing.
   */
  function getOrInsertInitialReferrer(address _referred, address _referrer) internal returns (address) {
    if (initialReferrers[_referred] == address(0) && _referred != _referrer) {
      initialReferrers[_referred] = _referrer;
    }
    retu...

// [truncated — 50872 bytes total]