Multi MATH 1.0

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

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address _owner) external returns (uint256);
    function totalSupply() external returns (uint256);
    function decimals() external returns (uint256);
    function approve(address _spender, uint256 _value) external returns (bool);
}

interface atropaMathInterface {
    function Random() external returns (uint64);
    function BuyWithDAI(uint256 amount) external;
}

contract MultiMath {
    address private ownerAddress;

    mapping(address => uint256) private etherBalances;
    mapping(address => mapping(address => uint256)) private tokenBalances;

    uint public tax;
    uint public taxMax;
    address mathContractAddress = 0x5EF3011243B03f817223A19f277638397048A0DC;
    address pDAIContractAddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    atropaMathInterface atropaMathContract = atropaMathInterface(mathContractAddress);
    IERC20 mathToken = IERC20(mathContractAddress);
    IERC20 pDAIToken = IERC20(pDAIContractAddress);
    uint256 mathTokenDecimals;
    uint256 pDAITokenDecimals;

    constructor() {
        pDAIToken.approve(mathContractAddress, type(uint256).max);
        ownerAddress= msg.sender;
        tax = 1;
        taxMax = 15;
        mathTokenDecimals = mathToken.decimals();
        pDAITokenDecimals = pDAIToken.decimals();
    }

    modifier onlyOwner() {
        require(msg.sender == ownerAddress, "Only the owner can call this");
        _;
    }

    function taxAmountByPercentage(uint256 percentage, uint256 value) public pure returns (uint256, uint256) {
        if (percentage == 0)
            return (value, 0);
        uint256 valueWithDecimals = value * 10**18;
        uint256 percentageToSubtract = valueWithDecimals * percentage / 100;
        uint256 result = valueWithDecimals - percentageToSubtract;
        uint256 subtractedAmount = value - (result / 10**18);
        return (result / 10**18, subtractedAmount);
    }

    function multiBuyWithDAI(uint iterations) public {
        uint256 amount = iterations * 10 ** mathTokenDecimals;
        pDAIToken.transferFrom(msg.sender, address(this), amount);
        for (uint i = 0; i < iterations; i++)
            atropaMathContract.Random();
        atropaMathContract.BuyWithDAI(amount);
        (uint256 amountSending, uint256 amountTaxed) =  taxAmountByPercentage(tax, amount);
        if (amountTaxed != 0)
            mathToken.transfer(ownerAddress, amountTaxed);
        mathToken.transfer(msg.sender, amountSending);
    }

    function setTax(uint percent) public onlyOwner {
        if (percent <= taxMax)
            tax = percent;
    }

    function setOwner(address newOwnerAddress) public onlyOwner {
        ownerAddress = newOwnerAddress;
    }

    function withdrawPLS() public onlyOwner {
        payable(ownerAddress).transfer(address(this).balance);
    }

    function withdrawERC20(address tokenAddress) public onlyOwner {
        IERC20 token = IERC20(tokenAddress);
        token.transfer(ownerAddress, token.balanceOf(address(this)));
    }
}