SaleContract

/**
 *Submitted for verification at BscScan.com on 2025-10-03
*/

//SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.18;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not 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);
    }
}

interface IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 value) external;

    function transfer(address to, uint256 value) external;

    function transferFrom(address from, address to, uint256 value) external;

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);
}
 

contract SaleContract is Ownable { 
    IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7); 
 
 
    // Stats
    uint256 public cardboughtAmount;   
    uint256 public amountRaised;
    uint256 public amountRaisedUSDT; 
    uint256 public uniqueBuyers;
    uint256 public changePriceForUsdt;
    uint256 public changePriceForNative;
    uint256 public changeStage;
   

    address payable public fundReceiver;

    bool public presaleStatus;
    bool public isPresaleEnded; 

    address[] public UsersAddresses;
    struct User {
        uint256 native_balance;
        uint256 card_balance;
        uint256 usdt_balance; 
    }

    mapping(address => User) public users;
    mapping(address => bool) public isExist;

    event spent(address indexed _user, uint256 indexed _amount); 

    constructor(address _fundReceiver) { 
        fundReceiver = payable(_fundReceiver);  

    }
    function buyTokenCard(address _user, uint256 _tokenAmount) public payable {
        require(!isPresaleEnded, "Presale ended!");
        require(presaleStatus, " Presale is Paused, check back later");
        if (!isExist[_user]) {
            isExist[_user] = true;
            uniqueBuyers++;
            UsersAddresses.push(_user);
        }
        fundReceiver.transfer(msg.value);
   
        amountRaised = amountRaised + msg.value; 
        users[_user].card_balance = users[_user].card_balance + (msg.value);
       emit spent(_user, _tokenAmount);
           }

    // to buy token during preSale time with Eth => for web3 use
    function buyToken() public payable {
        require(!isPresaleEnded, "Presale ended!");
        require(presaleStatus, " Presale is Paused, check back later");
        if (!isExist[msg.sender]) {
            isExist[msg.sender] = true;
            uniqueBuyers++;
            UsersAddresses.push(msg.sender);
        }
        fundReceiver.transfer(msg.value); 
        amountRaised = amountRaised + (msg.value); 

        users[msg.sender].native_balance =
            users[msg.sender].native_balance +
            (msg.value);  
    }

    // to buy token during preSale time with USDT => for web3 use
    function buyTokenUSDT(uint256 amount) public {
        require(!isPresaleEnded, "Presale ended!");
        require(presaleStatus, " Presale is Paused, check back later");
        if (!isExist[msg.sender]) {
            isExist[msg.sender] = true;
            uniqueBuyers++;
            UsersAddresses.push(msg.sender);
        }
        USDT.transferFrom(msg.sender, fundReceiver, amount);
 
        amountRaisedUSDT = amountRaisedUSDT + amount; 

        users[msg.sender].usdt_balance += amount;  
    }    
    function setPresaleStatus(bool _status) external onlyOwner {
        presaleStatus = _status;
    }
    function updateData(uint256 usdtPrice, uint256 nativePrice, uint256 stage) external onlyOwner {
    changePriceForUsdt = usdtPrice;
      changePriceForNative = nativePrice;
      changeStage = stage;
          }

    function endPresale() external onlyOwner {
        isPresaleEnded = true; 
    }   
    //change tokens for buy
    function updateStableTokens(IERC20 _USDT) external onlyOwner {
        USDT = IERC20(_USDT);
    }

    // to withdraw funds for liquidity
    function initiateTransfer(uint256 _value) external onlyOwner {
        fundReceiver.transfer(_value);
    }

    // to withdraw funds for liquidity
    function changeFundReciever(address _addr) external onlyOwner {
        fundReceiver = payable(_addr);
    } 
    // to withdraw out tokens
    function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
        token.transfer(msg.sender, _value);
    }

    function totalUsersCount() external view returns (uint256) {
        return UsersAddresses.length;
    }
}