// File: src/USATokenOwner.sol



// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;

import "./interfaces/IUSATokenV1.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract USATokenOwner is Ownable {
    address public constant USA_TOKEN_ADDRESS = 0x4FFe9CC172527DF1E40D0b2EfE1e9F05884A13dA;
    IUSATokenV1 public constant USA_TOKEN = IUSATokenV1(USA_TOKEN_ADDRESS);
    uint256 public constant MAX_SELL_TAX_FEE = 5 * 1e6; // max 5% sell fee
    uint256 public constant MAX_BUY_TAX_FEE = 5 * 1e6; // max 5% buy fee

    bool public lockSwapHelper = false;

    /**
     * This contract is the permanent owner of the USA token contract. This contract does not have the ability to change the ownership of the USA token contract (it lacks the ability to call the transferOwnership function in the USA Token contract).
     *
     * The ownership of this contract can be transferred to another address, but the ownership of the USA token contract cannot be transferred to another address.
     *
     * The purpose of this USA Owner contract is to contractlly enforce the following:
     * - That the mint() function can never be called again since this contract is the owner and it lacks the ability to call the mint() function
     *  - That the burn() function can never be called again since this contract is the owner and it lacks the ability to call the burn() function
     * - That the buy and sell taxes can never be higher than 5% (5 * 1e6)
     *  - The blacklistAddress function can never be called again since this contract is the owner and it lacks the ability to call the blacklistAddress function
     *  - This contract does have the ability to change the swapHelper, but this ability can be locked permanently by calling the lockSwapHelperForever function
     */

    constructor(address _ownerAddress) Ownable(_ownerAddress) {}

    /**
     * function that calls manual swap in the USA token contract, which sells collected taxes into the configured lp pool
     */
    function manualSwap() external onlyOwner {
        USA_TOKEN.manualSwap();
    }

    /**
     * @dev function that withdraws tokens from the contract
     * @param _token the token address to withdraw
     * @param _to the address to send the tokens to
     * @param _amount the amount of tokens to withdraw
     */
    function withdrawTokens(address _token, address _to, uint256 _amount) external onlyOwner {
        USA_TOKEN.withdrawTokens(_token, _to, _amount);
    }

    /**
     * @dev function that withdraws all available USA and sends it to the owner
     */
    function withdrawAllUsaToOwner() external onlyOwner {
        uint256 _amount = IERC20(USA_TOKEN_ADDRESS).balanceOf(USA_TOKEN_ADDRESS);
        USA_TOKEN.withdrawTokens(USA_TOKEN_ADDRESS, owner(), _amount);
    }

    /**
     * @dev Add registered swap contract, for enforcement of sell and buy taxes
     * @param _swapContract the swap contract address of the dex
     * @param _setting bool setting, true is to add, false is to remove
     */
    function addRegisteredSwapContract(address _swapContract, bool _setting) external onlyOwner {
        USA_TOKEN.addRegisteredSwapContract(_swapContract, _setting);
    }

    /**
     * @dev Set minimum swap amount for selling on a usa sell action
     * @param _minSwapAmount min swap amount for auto selling of taxes
     */
    function setMinSwapAmount(uint256 _minSwapAmount) external onlyOwner {
        USA_TOKEN.setMinSwapAmount(_minSwapAmount);
    }

    /**
     * @dev Set excluded from fee address
     * @param _address address to set / exclude from being charged taxes
     * @param _excluded true to exclude, false to (re)include
     */
    function setExcludedFromFee(address _address, bool _excluded) external onlyOwner {
        USA_TOKEN.setExcludedFromFee(_address, _excluded);
    }

    /**
     * @dev Set tax fee charged on USA buys
     * @param _taxFeeOnBuy tax fee on buy
     *  @notice tax can be max 5% (5 * 1e6)
     */
    function setTaxFeeOnBuy(uint256 _taxFeeOnBuy) external onlyOwner {
        require(_taxFeeOnBuy <= MAX_BUY_TAX_FEE, "USATokenOwner: taxFeeOnBuy is too high");
        USA_TOKEN.setTaxFeeOnBuy(_taxFeeOnBuy);
    }

    /**
     * @dev Set tax fee charged on USA sells
     * @param _taxFeeOnSell tax fee on sell
     *  @notice tax can be max 5% (5 * 1e6)
     */
    function setTaxFeeOnSell(uint256 _taxFeeOnSell) external onlyOwner {
        require(_taxFeeOnSell <= MAX_SELL_TAX_FEE, "USATokenOwner: taxFeeOnSell is too high");
        USA_TOKEN.setTaxFeeOnSell(_taxFeeOnSell);
    }

    /**
     * @dev Set swap to eth on sell action of usa token
     * @param _swapToEthOnSell bool to swap to eth on sell, false to disable 'automatic' tax swapping
     */
    function setSwapToEthOnSell(bool _swapToEthOnSell) external onlyOwner {
        USA_TOKEN.setSwapToEthOnSell(_swapToEthOnSell);
    }

    /**
     * @dev Set dao tax receiver address in the USA contract (where the dao tax in weth is sent to)
     * @param _daoTaxReceiver address to set as dao tax receiver
     */
    function setDaoTaxReceiver(address _daoTaxReceiver) external onlyOwner {
        require(_daoTaxReceiver != address(0), "USATokenOwner: daoTaxReceiver is zero address");
        USA_TOKEN.setDaoTaxReceiver(_daoTaxReceiver);
    }

    /**
     * @dev change swap helper address, the swap helper is used to swap tokens to weth
     * @param _swapHelper address of the swap helper
     * @notice this function can only be called if the swap helper is not locked permanently
     *  @notice the reason there is a configurable swap helper to begin with is that we want to be able to change the swap helper in case of a new version of uniswap (like v4). This way we can upgrade the swap helper contract and change the address in the USA contract. to make sure the swap helper address is not changed maliciously, we can lock the swap helper address permanently if we want to.
     */
    function changeSwapHelper(address _swapHelper) external onlyOwner {
        require(!lockSwapHelper, "USATokenOwner: swapHelper is locked");
        USA_TOKEN.changeSwapHelper(_swapHelper);
    }

    /**
     * @dev enable or disable fees on the USA token
     * @param _value true to enable fees, false to disable fees
     */
    function enableOrDisableFees(bool _value) external onlyOwner {
        USA_TOKEN.enableOrDisableFees(_value);
    }

    /**
     * @notice function that allows for withdrawal of tokens that are accidentally sent to this ownership contract
     * @param _token the token address to withdraw
     * @param _to the address to send the tokens to
     * @param _amount the amount of tokens to withdraw
     */
    function removeTokensFromContract(address _token, address _to, uint256 _amount) external onlyOwner {
        IERC20(_token).transfer(_to, _amount);
    }

    /**
     * @dev function that locks the swap helper address permanently so that it cannot be changed anymore
     * @notice this function can only be called once
     */
    function lockSwapHelperForever() external onlyOwner {
        lockSwapHelper = true;
    }
}

// File: src/interfaces/IUSATokenV1.sol



// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;

interface IUSATokenV1 {
    function manualSwap() external;
    function withdrawTokens(address _token, address _to, uint256 _amount) external;
    function addRegisteredSwapContract(address _swapContract, bool _setting) external;
    function setMinSwapAmount(uint256 _minSwapAmount) external;
    function setExcludedFromFee(address _address, bool _excluded) external;
    function setTaxFeeOnBuy(uint256 _taxFeeOnBuy) external;
    function setTaxFeeOnSell(uint256 _taxFeeOnSell) external;
    function setSwapToEthOnSell(bool _swapToEthOnSell) external;
    function setDaoTaxReceiver(address _daoTaxReceiver) external;
    function changeSwapHelper(address _swapHelper) external;
    function enableOrDisableFees(bool _value) external;
}

// File: lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: lib/openzeppelin-contracts/contracts/access/Ownable.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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: lib/openzeppelin-contracts/contracts/utils/Context.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }
}