XETH (XETH)

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

interface IDEXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IDEXRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
}

interface IERC20 {
    function approve(address spender, uint256 amount) external returns (bool);
}

contract Ownable {
    address internal _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    modifier onlyOwner() {
        require(msg.sender == _owner, "Not owner");
        _;
    }

    function owner() public view returns (address) {
        return _owner;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        _owner = newOwner;
        emit OwnershipTransferred(msg.sender, newOwner);
    }
}

// Mock structs for your fee setup — keep or adjust as per your original
struct Allot { uint256 liquidity; uint256 marketing; uint256 burn; uint256 dividend; uint256 total; }
struct Fee { uint256 buy; uint256 sell; uint256 transfer; uint256 denominator; }

contract TokenDistributor {
    constructor(address rewardToken) {}
}

contract DividendDistributor {
    constructor(address rewardToken, uint256 minPeriod, uint256 minDistribution, uint256 minHold) {}
}

contract XETH is Ownable {
    // --------------------------------
    // Core Variables
    // --------------------------------
    string private constant _name = "XETH";
    string private constant _symbol = "XETH";
    uint8 private constant _decimals = 18;
    uint256 private constant _totalSupply = 1_000_000 * 10**_decimals;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public isTxLimitExempt;
    mapping(address => bool) public isWalletLimitExempt;
    mapping(address => bool) public isDividendExempt;

    // --------------------------------
    // Router, Tokens, and Pair
    // --------------------------------
    address public rewardToken; // XAUt (Gold)
    address public baseToken;   // WETH (for pair)
    address public pair;
    IDEXRouter public router;

    TokenDistributor public _tokenDistributor;
    DividendDistributor public distributor;

    Allot public allot;
    Fee public fees;
    address public marketingFeeReceiver;

    // --------------------------------
    // Constructor
    // --------------------------------
    constructor () Ownable() {
        router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // UniswapV2 router

        rewardToken = address(0x68749665FF8D2d112Fa859AA293F07A622782F38); // XAUt (Gold)
        baseToken   = router.WETH(); // use WETH for pair (XETH/ETH)

        pair = IDEXFactory(router.factory()).createPair(baseToken, address(this));

        _allowances[address(this)][address(router)] = type(uint256).max;

        _tokenDistributor = new TokenDistributor(rewardToken);
        distributor = new DividendDistributor(
            rewardToken,
            5 minutes,
            1 * 10 ** 18,
            _totalSupply / 10000
        );

        IERC20(rewardToken).approve(address(router), type(uint256).max);

        // Exemptions
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(router)] = true;
        isFeeExempt[address(this)] = true;
        isTxLimitExempt[msg.sender] = true;
        isWalletLimitExempt[msg.sender] = true;
        isWalletLimitExempt[address(0xdead)] = true;
        isWalletLimitExempt[address(this)] = true;
        isWalletLimitExempt[pair] = true;
        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[address(0xdead)] = true;

        // Fees
        allot = Allot(2, 2, 0, 6, 10);
        fees = Fee(10, 10, 0, 100);
        marketingFeeReceiver = msg.sender;

        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    // --------------------------------
    // Basic ERC20 Functions
    // --------------------------------
    function name() public pure returns (string memory) { return _name; }
    function symbol() public pure returns (string memory) { return _symbol; }
    function decimals() public pure returns (uint8) { return _decimals; }
    function totalSupply() public pure returns (uint256) { return _totalSupply; }
    function balanceOf(address account) public view returns (uint256) { return _balances[account]; }

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