Address

• contracts/ptrailx1.sol

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

interface IERC20 {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
}

contract PTRAILX1 {
    string public constant name = "PTRAILX";
    string public constant symbol = "PTRAILX";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    address public owner;
    address public lpPair;
    address constant PTRAIL = 0x146c165DD68bCe30bF75B46010eF12605A315e14; // PTRAIL for minting

    uint256 public constant MINT_PRICE = 4 * 10**18;   // 1 PTRAILX = 4 PTRAIL
    uint256 public constant SELLBACK_RATIO = 50;
    uint256 public constant DEX_SELL_TAX = 40;

    address public stakingContract;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Mint(address indexed to, uint256 amount);
    event SellBack(address indexed from, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event DexSellTaxed(address indexed from, uint256 taxedAmount);

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

    modifier onlyStaking() {
        require(msg.sender == stakingContract, "Not staking contract");
        _;
    }

    constructor(address _owner) {
        owner = _owner;
    }

    function mint(uint256 quantity) external {
        require(quantity > 0, "Quantity must be > 0");
        uint256 totalCost = quantity * MINT_PRICE;
        require(IERC20(PTRAIL).transferFrom(msg.sender, owner, totalCost), "Payment failed");

        uint256 amount = quantity * 10**decimals;
        balanceOf[msg.sender] += amount;
        totalSupply += amount;

        emit Transfer(address(0), msg.sender, amount);
        emit Mint(msg.sender, amount);
    }

    function mintFromStakingContract(address to, uint256 quantity) external onlyStaking {
        require(quantity > 0, "Quantity must be > 0");
        uint256 pTrailNeeded = quantity * MINT_PRICE;
        require(IERC20(PTRAIL).balanceOf(msg.sender) >= pTrailNeeded, "Not enough PTRAIL in staking");

        IERC20(PTRAIL).transferFrom(msg.sender, owner, pTrailNeeded);

        uint256 amount = quantity * 10**decimals;
        balanceOf[to] += amount;
        totalSupply += amount;

        emit Transfer(address(0), to, amount);
        emit Mint(to, amount);
    }

    function sellBack(uint256 quantity) external {
        require(quantity > 0, "Quantity must be > 0");
        uint256 amount = quantity * 10**decimals;
        require(balanceOf[msg.sender] >= amount, "Insufficient PTRAILX balance");

        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;

        uint256 payout = (quantity * MINT_PRICE * SELLBACK_RATIO) / 100;
        require(IERC20(PTRAIL).transferFrom(owner, msg.sender, payout), "Payout failed");

        emit Transfer(msg.sender, address(0), amount);
        emit SellBack(msg.sender, amount);
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        return _transfer(msg.sender, to, amount);
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "Allowance exceeded");
        allowance[from][msg.sender] -= amount;
        return _transfer(from, to, amount);
    }

    function _transfer(address from, address to, uint256 amount) internal returns (bool) {
        require(balanceOf[from] >= amount, "Insufficient balance");
        balanceOf[from] -= amount;

        if (to == lpPair) {
            uint256 taxedAmount = (amount * DEX_SELL_TAX) / 100;
            uint256 sendAmount = amount - taxedAmount;

            balanceOf[to] += sendAmount;
            balanceOf[owner] += taxedAmount;

            emit Transfer(from, to, sendAmount);
            emit Transfer(from, owner, taxedAmount);
            emit DexSellTaxed(from, taxedAmount);
        } else {
            balanceOf[to] += amount;
            emit Transfer(from, to, amount);
        }

        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function getAllowance(address _owner, address _spender) external view returns (uint256) {
        return allowance[_owner][_spender];
    }

    function setLP(address _lp) external onlyOwner {
        lpPair = _lp;
    }

    function setStakingContract(address _staking) external onlyOwner {
        stakingContract = _staking;
    }
}