Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

//SPDX-License-Identifier: MIT

/**

.BLASTMOON
.WEB: BLASTMOON.IO
.TG: @BLASTMOONIO
.X: @BLASTMOONIO
.MEDIUM: @BLASTMOONIO

      .--.   |V|
     /    \ _| /
     q .. p \ /
      \--/  //
     __||__//
    /.    _/
   // \  /
  //   ||
  \\  /  \
   )\|    |
  / || || |
  |/\| || |
     | || |
     \ || /
   __/ || \__
  \____/\____/

*/


pragma solidity ^0.8.18;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SafeMath} from "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {IDEXFactory} from "./IDEXFactory.sol";
import {IDEXRouter} from "./IDEXRouter.sol";
import {IBlast} from "./IBlast.sol";

contract BlastMoon is IERC20, Ownable {
    using SafeMath for uint256;
    IBlast private constant BLAST = IBlast(0x4300000000000000000000000000000000000002);

    address private constant ROUTER = 0x98994a9A7a2570367554589189dC9772241650f6; 
    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;

    string private constant _name = "BlastMoon";
    string private constant _symbol = "BMOON";
    uint8 private constant _decimals = 18;

    uint256 private constant _totalSupply = 10 * 10 ** 7 * 10 ** _decimals;  

    /* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
    mapping(address => uint256) public _rOwned;
    uint256 public _totalProportion = _totalSupply;

    mapping(address => mapping(address => uint256)) private _allowances;

    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public isTxLimitExempt;

    uint256 public teamFeeBuy = 0;  
    uint256 public marketingFeeBuy = 100;  
    uint256 public reflectionFeeBuy = 200; 

    uint256 public teamFeeSell = 100; 
    uint256 public marketingFeeSell = 200; 
    uint256 public reflectionFeeSell = 200; 

    uint256 private constant feeDenominator = 10000;

    uint256 public totalFeeBuy = marketingFeeBuy + teamFeeBuy + reflectionFeeBuy;
    uint256 public totalFeeSell = marketingFeeSell + teamFeeSell + reflectionFeeSell;

    address public marketingFeeReceiver;
    address public teamFeeReceiver;

    IDEXRouter public router;
    address public pair;

    address public feeExemptSetter;
    address public blastOperator;

    bool public tradingOpen = false;

    bool public claimingFees = true;
    bool private alternateSwaps = true;
    uint256 private smallSwapThreshold = (_totalSupply * 2) / 1000;
    uint256 private largeSwapThreshold = (_totalSupply * 3) / 1000;

    uint256 public swapThreshold = smallSwapThreshold;
    bool private inSwap;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    modifier onlyFeeExemptSetter() {
        require(msg.sender == feeExemptSetter, "Not fee exempt setter");
        _;
    }

    modifier onlyBlastOperator() {
        require(msg.sender == blastOperator, "Not blast operator");
        _;
    }

    constructor() {
        BLAST.configureClaimableGas();

        router = IDEXRouter(ROUTER);
        pair = IDEXFactory(router.factory()).createPair(
            address(this),
            router.WETH()
        );
        _allowances[address(this)][address(router)] = type(uint256).max;
        _allowances[address(this)][msg.sender] = type(uint256).max;

        isTxLimitExempt[address(this)] = true;
        isTxLimitExempt[address(router)] = true;
        isTxLimitExempt[pair] = true;
        isTxLimitExempt[msg.sender] = true;
        isFeeExempt[msg.sender] = true;
        teamFeeReceiver = msg.sender;
        feeExemptSetter = msg.sender;
        blastOperator = msg.sender;
        marketingFeeReceiver = 0xBabe6a2490A81c549CBe7aAfF2c1F2CC3cf9CA69;  

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

    receive() external payable {}

    function totalSupply() external pure override returns (uint256) {
        return _totalSupply;
    }

    function decimals() external pure returns (uint8) {
        return _decimals;
    }

    function name() external pure returns (string memory) {
        return _name;
    }

    function symbol() external pure returns (string memory) {
        return _symbol;
    }

    function getOwner() external view returns (address) {
        return owner();
    }

    function balanceOf(address account) public view override returns (uint256) {
        return tokenFromReflection(_rOwned[account]);
    }

    function allowance(
        address holder,
        address spender
    ) external view override returns (uint256) {
        return _allowances[holder][spender];
    }

    function viewFeesBuy()
        external
        view
        returns (uint256, uint256, uint256, uint256, uint256)
    {
        return (
            marketingFeeBuy,
            teamFeeBuy,
            reflectionFeeBuy,
            totalFeeBuy,
            feeDenominator
        );
    }

    function viewFeesSell()
        external
        view
        returns (uint256, uint256, uint256, uint256, uint256)
    {
        return (
            marketingFeeSell,
            teamFeeSell,
            reflectionFeeSell,
            totalFeeSell,
            feeDenominator
        );
    }

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

    function approveMax(address spender) external returns (bool) {
        return approve(spender, type(uint256).max);
    }

    function transfer(
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        return _transferFrom(msg.sender, recipient, amount);
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        if (_allowances[sender][msg.sender] != type(uint256).max) {
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender]
                .sub(amount, "Insufficient Allowance");
        }

        return _transferFrom(sender, recipient, amount);
    }

    function _transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        if (inSwap) {
            return _basicTransfer(sender, recipient, amount);
        }

        if (
            recipient != pair &&
            recipient != DEAD &&
            !isTxLimitExempt[recipient]
        ) {
            require(tradingOpen, "Trading not open yet");
        }

        if (shouldSwapBack()) {
            swapBack();
        }

        uint256 proportionAmount = tokensToProportion(amount);

        _rOwned[sender] = _rOwned[sender].sub(
            proportionAmount,
            "Insufficient Balance"
        );

        uint256 proportionReceived = shouldTakeFee(sender, recipient)
            ? takeFeeInProportions(
                sender == pair ? true : false,
                sender,
                recipient,
                proportionAmount
            )
            : proportionAmount;
        _rOwned[recipient] = _rOwned[recipient].add(proportionReceived);

        emit Transfer(
            sender,
            recipient,
            tokenFromReflection(proportionReceived)
        );
        return true;
    }

    function tokensToProportion(uint256 tokens) public view returns (uint256) {
        return tokens.mul(_totalProportion).div(_totalSupply);
    }

    function tokenFromReflection(
        uint256 proportion
    ) public view returns (uint256) {
        return proportion.mul(_totalSupply).div(_totalProportion);
    }

    function _basicTransfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        uint256 proportionAmount = tokensToProportion(amount);
        _rOwned[sender] = _rOwned[sender].sub(
            proportionAmount,
            "Insufficient Balance"
        );
        _rOwned[recipient] = _rOwned[recipient].add(proportionAmount);
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function shouldTakeFee(
        address sender,
        address recipient
    ) internal view returns (bool) {
        return !isFeeExempt[sender] && !isFeeExempt[recipient];
    }

    function getTotalFeeBuy(bool) public view returns (uint256) {
        return totalFeeBuy;
    }

    function getTotalFeeSell(bool) public view returns (uint256) {
        return totalFeeSell;
    }

    function takeFeeInProportions(
        bool buying,
        address sender,
        address receiver,
        uint256 proportionAmount
    ) internal returns (uint256) {
        uint256 proportionFeeAmount = buying == true
            ? proportionAmount.mul(getTotalFeeBuy(receiver == pair)).div(
                feeDenominator
            )
            : proportionAmount.mul(getTotalFeeSell(receiver == pair)).div(
                feeDenominator
            );

        // reflect
        uint256 proportionReflected = buying == true
            ? proportionFeeAmount.mul(reflectionFeeBuy).div(totalFeeBuy)
            : proportionFeeAmount.mul(reflectionFeeSell).div(totalFeeSell);

        _totalProportion = _totalProportion.sub(proportionReflected);

        // take fees
        uint256 _proportionToContract = proportionFeeAmount.sub(
            proportionReflected
        );
        if (_proportionToContract > 0) {
            _rOwned[address(this)] = _rOwned[address(this)].add(
                _proportionToContract
            );

            emit Transfer(
                sender,
                address(this),
                tokenFromReflection(_proportionToContract)
            );
        }
        emit Reflect(proportionReflected, _totalProportion);
        return proportionAmount.sub(proportionFeeAmount);
    }

    function clearStuckBalance() external onlyOwner {
        (bool success, ) = payable(msg.sender).call{
            value: address(this).balance,
            gas: 30000
        }("");
        require(success);
    }

    function clearForeignToken(
        address tokenAddress,
        uint256 tokens
    ) public returns (bool) {
        require(isTxLimitExempt[msg.sender]);
        require(tokenAddress != address(this), "Not allowed");
        if (tokens == 0) {
            tokens = IERC20(tokenAddress).balanceOf(address(this));
        }
        return IERC20(tokenAddress).transfer(msg.sender, tokens);
    }

    function shouldSwapBack() internal view returns (bool) {
        return
            msg.sender != pair &&
            !inSwap &&
            claimingFees &&
            balanceOf(address(this)) >= swapThreshold;
    }

    function swapBack() internal swapping {
        uint256 _totalFee = totalFeeSell.sub(reflectionFeeSell);
        uint256 amountToSwap = swapThreshold;
        approve(address(router), amountToSwap);

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amountETH = address(this).balance;

        uint256 totalETHFee = _totalFee;
        uint256 amountETHMarketing = amountETH.mul(marketingFeeSell).div(
            totalETHFee
        );
        uint256 amountETHteam = amountETH.mul(teamFeeSell).div(totalETHFee);

        (bool tmpSuccess, ) = payable(marketingFeeReceiver).call{
            value: amountETHMarketing,
            gas: 30000
        }("");
        (tmpSuccess, ) = payable(teamFeeReceiver).call{
            value: amountETHteam,
            gas: 30000
        }("");

        swapThreshold = !alternateSwaps
            ? swapThreshold
            : swapThreshold == smallSwapThreshold
            ? largeSwapThreshold
            : smallSwapThreshold;
    }

    function setSwapBackSettings(
        bool _enabled,
        uint256 _amountS,
        uint256 _amountL,
        bool _alternate
    ) external onlyOwner {
        alternateSwaps = _alternate;
        claimingFees = _enabled;
        smallSwapThreshold = _amountS;
        largeSwapThreshold = _amountL;
        swapThreshold = smallSwapThreshold;
    }

    function enableTrading() public onlyOwner {
        tradingOpen = true;
    }

    function changeFees(
        uint256 _reflectionFeeBuy,
        uint256 _marketingFeeBuy,
        uint256 _teamFeeBuy,
        uint256 _reflectionFeeSell,
        uint256 _marketingFeeSell,
        uint256 _teamFeeSell
    ) external onlyOwner {
        reflectionFeeBuy = _reflectionFeeBuy;
        marketingFeeBuy = _marketingFeeBuy;
        teamFeeBuy = _teamFeeBuy;
        totalFeeBuy = reflectionFeeBuy.add(marketingFeeBuy).add(teamFeeBuy);

        reflectionFeeSell = _reflectionFeeSell;
        marketingFeeSell = _marketingFeeSell;
        teamFeeSell = _teamFeeSell;
        totalFeeSell = reflectionFeeSell.add(marketingFeeSell).add(teamFeeSell);

        require(totalFeeBuy <= 1000, "Cannot set buy fees above 10%"); // max fee possible
        require(totalFeeSell <= 1000, "Cannot set sell fees above 10%"); // max fee possible
    }

    function setIsFeeExempt(
        address holder,
        bool exempt
    ) external onlyFeeExemptSetter {
        isFeeExempt[holder] = exempt;
    }

    function changeFeeExemptSetter(
        address _feeExemptSetter
    ) external onlyFeeExemptSetter {
        feeExemptSetter = _feeExemptSetter;
    }

    function renounceFeeExemptSetter() external onlyFeeExemptSetter {
        feeExemptSetter = address(0);
    }

    function changeBlastOperator(
        address _blastOperator
    ) external onlyBlastOperator() {
        require(_blastOperator != address(0), "Invalid address");
        blastOperator = _blastOperator;
    }

    function claimAllGas(address recipient) external onlyBlastOperator() {
        BLAST.claimAllGas(address(this), recipient);
    }

    function setIsTxLimitExempt(
        address holder,
        bool exempt
    ) external onlyOwner {
        isTxLimitExempt[holder] = exempt;
    }

    function setFeeReceivers(
        address _marketingFeeReceiver,
        address _teamFeeReceiver
    ) external onlyOwner {
        marketingFeeReceiver = _marketingFeeReceiver;
        teamFeeReceiver = _teamFeeReceiver;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
    }

    event Reflect(uint256 amountReflected, uint256 newTotalProportion);
}

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

pragma solidity ^0.8.18;

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.
 */
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() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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

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

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

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

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

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

interface IBlast {
  function configureClaimableGas() external;
  function claimAllGas(address contractAddress, address recipient) external returns (uint256);
}

contract BlastGClaim {
    IBlast public constant BLAST = IBlast(0x4300000000000000000000000000000000000002);
    address public immutable OWNER;

    constructor() {
        OWNER = msg.sender;
    }

    function claimAllGas(address recipient) external payable {
        require(msg.sender == OWNER, "Only owner");
        BLAST.claimAllGas(address(this), recipient);
    }

    function configureClaimableGas() external payable {
        require(msg.sender == OWNER, "Only owner");
        BLAST.configureClaimableGas();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// 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);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountReflected","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalProportion","type":"uint256"}],"name":"Reflect","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_rOwned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_totalProportion","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"approveMax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blastOperator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_blastOperator","type":"address"}],"name":"changeBlastOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeExemptSetter","type":"address"}],"name":"changeFeeExemptSetter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_reflectionFeeBuy","type":"uint256"},{"internalType":"uint256","name":"_marketingFeeBuy","type":"uint256"},{"internalType":"uint256","name":"_teamFeeBuy","type":"uint256"},{"internalType":"uint256","name":"_reflectionFeeSell","type":"uint256"},{"internalType":"uint256","name":"_marketingFeeSell","type":"uint256"},{"internalType":"uint256","name":"_teamFeeSell","type":"uint256"}],"name":"changeFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"claimAllGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimingFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"clearForeignToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clearStuckBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeExemptSetter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"","type":"bool"}],"name":"getTotalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"","type":"bool"}],"name":"getTotalFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isTxLimitExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketingFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reflectionFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reflectionFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceFeeExemptSetter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IDEXRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_marketingFeeReceiver","type":"address"},{"internalType":"address","name":"_teamFeeReceiver","type":"address"}],"name":"setFeeReceivers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsTxLimitExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"},{"internalType":"uint256","name":"_amountS","type":"uint256"},{"internalType":"uint256","name":"_amountL","type":"uint256"},{"internalType":"bool","name":"_alternate","type":"bool"}],"name":"setSwapBackSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"teamFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"proportion","type":"uint256"}],"name":"tokenFromReflection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"tokensToProportion","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"tradingOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"viewFeesBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewFeesSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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