Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED

// website: https://www.fissionsonic.com/
// tg: https://t.me/FissionPortal
// x: https://x.com/FissionSonic

pragma solidity >=0.8.24;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/IRouter.sol";
import "./interfaces/IPairFactory.sol";
import "./interfaces/IManager.sol";

contract Fission is ERC20Burnable {
    IManager public Manager;
    address public Treasury;
    address public Bonds;
    address public Staking;

    mapping(address => bool) private _isExcludedFromFee;
    uint256 private _marketingFee = 50;

    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    IERC20 public OS = IERC20(0xb1e25689D55734FD3ffFc939c4C3Eb52DFf8A794);

    uint256 public _finalBuyTax = 0;
    uint256 public _finalSellTax = 0;

    uint256 private _tTotal = 2_000_000 * 1e18;
    uint256 private swapThreshold = (_tTotal * 30) / 10000;

    IRouter private router;
    address public pair;
    bool private initialized = false;
    bool public tradingOpen = false;
    bool private inSwap = false;
    bool private swapEnabled = false;

    IRouter.route[] private routes;

    constructor(address _manager) ERC20("Fission", "FSSN") {
        router = IRouter(0xF5F7231073b3B41c04BA655e1a7438b1a7b29c27);
        routes.push(IRouter.route(address(this), address(OS), false));

        Manager = IManager(_manager);

        _isExcludedFromFee[msg.sender] = true;
        _isExcludedFromFee[address(this)] = true;

        _approve(address(this), address(router), type(uint256).max);

        _mint(msg.sender, _tTotal);

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

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

    modifier lockTheSwap() {
        inSwap = true;
        _;
        inSwap = false;
    }

    function setRouter(address _router) external onlyOwner {
        router = IRouter(_router);
    }

    function setIsExcludedFromFee(
        address _address,
        bool _isExcluded
    ) external onlyOwner {
        _isExcludedFromFee[_address] = _isExcluded;
    }

    function setMarketingFee(uint256 marketingFee) external onlyOwner {
        _marketingFee = marketingFee;
    }

    function downSellingFee(uint256 _newFee) external onlyOwner {
        require(_newFee <= 12, "Fee too high");
        _finalSellTax = _newFee;
    }

    function initializePair() external onlyOwner returns (address) {
        require(!initialized, "Already initialized");
        pair = IPairFactory(router.factory()).createPair(
            address(this),
            address(OS),
            false
        );
        initialized = true;

        return pair;
    }

    function setPair(address _pair) external onlyOwner {
        pair = _pair;
    }

    function setIsInitialized(bool _initialized) external onlyOwner {
        initialized = _initialized;
    }

    function setSwapThreshold(uint256 newTax) external onlyOwner {
        swapThreshold = newTax;
    }

    function rescueTokens(address token, uint256 amount) external onlyOwner {
        IERC20(token).transfer(msg.sender, amount);
    }

    function rescueNative(uint256 amount) external onlyOwner {
        bool tmpSuccess;
        (tmpSuccess, ) = payable(msg.sender).call{value: amount, gas: 5000000}(
            ""
        );
    }

    function setAll() external onlyOwner {
        Treasury = _getContract("Treasury");
        Bonds = _getContract("Bonds");
        Staking = _getContract("Staking");
    }

    function openTrading() external onlyOwner {
        require(!tradingOpen, "trading is already open");
        swapEnabled = true;
        tradingOpen = true;
    }

    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(
            initialized || msg.sender == Manager.owner(),
            "Not yet initialized"
        );
        if (msg.sender == pair) {
            return update(msg.sender, recipient, amount);
        } else {
            return _basicTransfer(msg.sender, recipient, amount);
        }
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        address spender = msg.sender;
        _spendAllowance(sender, spender, amount);
        update(sender, recipient, amount);

        return true;
    }

    function update(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        require(
            _isExcludedFromFee[sender] ||
                _isExcludedFromFee[recipient] ||
                tradingOpen,
            "Not authorized to trade yet"
        );

        if (shouldSwapBack() && recipient == pair) {
            swapBack();
        }

        uint256 amountReceived = amount;
        if (!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]) {
            amountReceived = takeFee(sender, recipient, amountReceived);
        }

        _transfer(sender, recipient, amountReceived);

        return true;
    }

    function _basicTransfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {
        _transfer(sender, recipient, amount);
        return true;
    }

    function takeFee(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (uint256) {
        uint256 feeAmount = 0;
        uint256 tax;

        if (sender == pair && recipient != pair) {
            tax = _finalBuyTax;
        } else if (sender != pair && recipient == pair) {
            tax = _finalSellTax;
        }

        feeAmount = (amount * tax) / 100;

        if (feeAmount > 0) {
            _transfer(sender, address(this), feeAmount);
        }

        return amount - feeAmount;
    }

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

    function swapBack() internal lockTheSwap {
        uint256 amountToSwap = swapThreshold;

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            routes,
            address(this),
            block.timestamp + 5
        );

        uint256 amountDev = OS.balanceOf(address(this));

        if (amountDev > 0) {
            OS.transfer(Treasury, amountDev);
        }
    }

    function mint(address to, uint256 value) external {
        require(msg.sender == Bonds || msg.sender == Staking, "Not authorized");
        _mint(to, value);
    }

    receive() external payable {}

    function _getContract(
        string memory contractName
    ) internal view returns (address) {
        return Manager.getContract(contractName);
    }
}

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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.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: UNLICENSED
pragma solidity ^0.8.20;

interface IManager {
    function getContract(string memory name) external view returns (address);
    function owner() external view returns (address);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

interface IPairFactory {
    error FEE_TOO_HIGH();
    error ZERO_FEE();
    /// @dev invalid assortment
    error IA();
    /// @dev zero address
    error ZA();
    /// @dev pair exists
    error PE();
    error NOT_AUTHORIZED();
    error INVALID_FEE_SPLIT();

    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    event SetFee(uint256 indexed fee);

    event SetPairFee(address indexed pair, uint256 indexed fee);

    event SetFeeSplit(uint256 indexed _feeSplit);

    event SetPairFeeSplit(address indexed pair, uint256 indexed _feeSplit);

    event SkimStatus(address indexed _pair, bool indexed _status);

    event NewTreasury(address indexed _caller, address indexed _newTreasury);

    event FeeSplitWhenNoGauge(address indexed _caller, bool indexed _status);

    event SetFeeRecipient(address indexed pair, address indexed feeRecipient);

    /// @notice returns the total length of legacy pairs
    /// @return _length the length
    function allPairsLength() external view returns (uint256 _length);

    /// @notice calculates if the address is a legacy pair
    /// @param pair the address to check
    /// @return _boolean the bool return
    function isPair(address pair) external view returns (bool _boolean);

    /// @notice calculates the pairCodeHash
    /// @return _hash the pair code hash
    function pairCodeHash() external view returns (bytes32 _hash);

    /// @param tokenA address of tokenA
    /// @param tokenB address of tokenB
    /// @param stable whether it uses the stable curve
    /// @return _pair the address of the pair
    function getPair(
        address tokenA,
        address tokenB,
        bool stable
    ) external view returns (address _pair);

    /// @notice creates a new legacy pair
    /// @param tokenA address of tokenA
    /// @param tokenB address of tokenB
    /// @param stable whether it uses the stable curve
    /// @return pair the address of the created pair
    function createPair(
        address tokenA,
        address tokenB,
        bool stable
    ) external returns (address pair);

    /// @notice the address of the voter
    /// @return _voter the address of the voter
    function voter() external view returns (address _voter);

    /// @notice returns the address of a pair based on the index
    /// @param _index the index to check for a pair
    /// @return _pair the address of the pair at the index
    function allPairs(uint256 _index) external view returns (address _pair);

    /// @notice the swap fee of a pair
    /// @param _pair the address of the pair
    /// @return _fee the fee
    function pairFee(address _pair) external view returns (uint256 _fee);

    /// @notice the split of fees
    /// @return _split the feeSplit
    function feeSplit() external view returns (uint256 _split);

    /// @notice sets the swap fee for a pair
    /// @param _pair the address of the pair
    /// @param _fee the fee for the pair
    function setPairFee(address _pair, uint256 _fee) external;

    /// @notice set the swap fees of the pair
    /// @param _fee the fee, scaled to MAX 10% of 100_000
    function setFee(uint256 _fee) external;

    /// @notice the address for the treasury
    /// @return _treasury address of the treasury
    function treasury() external view returns (address _treasury);

    /// @notice sets the pairFees contract
    /// @param _pair the address of the pair
    /// @param _pairFees the address of the new Pair Fees
    function setFeeRecipient(address _pair, address _pairFees) external;

    /// @notice sets the feeSplit for a pair
    /// @param _pair the address of the pair
    /// @param _feeSplit the feeSplit
    function setPairFeeSplit(address _pair, uint256 _feeSplit) external;

    /// @notice whether there is feeSplit when there's no gauge
    /// @return _boolean whether there is a feesplit when no gauge
    function feeSplitWhenNoGauge() external view returns (bool _boolean);

    /// @notice whether a pair can be skimmed
    /// @param _pair the pair address
    /// @return _boolean whether skim is enabled
    function skimEnabled(address _pair) external view returns (bool _boolean);

    /// @notice set whether skim is enabled for a specific pair
    function setSkimEnabled(address _pair, bool _status) external;

    /// @notice sets a new treasury address
    /// @param _treasury the new treasury address
    function setTreasury(address _treasury) external;

    /// @notice set whether there should be a feesplit without gauges
    /// @param status whether enabled or not
    function setFeeSplitWhenNoGauge(bool status) external;

    /// @notice sets the feesSplit globally
    /// @param _feeSplit the fee split
    function setFeeSplit(uint256 _feeSplit) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;

interface IRouter {
    error EXPIRED();
    error IDENTICAL();
    error ZERO_ADDRESS();
    error INSUFFICIENT_AMOUNT();
    error INSUFFICIENT_LIQUIDITY();
    error INSUFFICIENT_OUTPUT_AMOUNT();
    error INVALID_PATH();
    error INSUFFICIENT_B_AMOUNT();
    error INSUFFICIENT_A_AMOUNT();
    error EXCESSIVE_INPUT_AMOUNT();
    error ETH_TRANSFER_FAILED();
    error INVALID_RESERVES();

    struct route {
        /// @dev token from
        address from;
        /// @dev token to
        address to;
        /// @dev is stable route
        bool stable;
    }

    function factory() external pure returns (address);
    function wETH() external pure returns (address);

    /// @notice sorts the tokens to see what the expected LP output would be for token0 and token1 (A/B)
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @return token0 address of which becomes token0
    /// @return token1 address of which becomes token1
    function sortTokens(
        address tokenA,
        address tokenB
    ) external pure returns (address token0, address token1);

    /// @notice calculates the CREATE2 address for a pair without making any external calls
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @return pair address of the pair
    function pairFor(
        address tokenA,
        address tokenB,
        bool stable
    ) external view returns (address pair);

    /// @notice fetches and sorts the reserves for a pair
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @return reserveA get the reserves for tokenA
    /// @return reserveB get the reserves for tokenB
    function getReserves(
        address tokenA,
        address tokenB,
        bool stable
    ) external view returns (uint256 reserveA, uint256 reserveB);

    /// @notice performs chained getAmountOut calculations on any number of pairs
    /// @param amountIn the amount of tokens of routes[0] to swap
    /// @param routes the struct of the hops the swap should take
    /// @return amounts uint array of the amounts out
    function getAmountsOut(
        uint256 amountIn,
        route[] memory routes
    ) external view returns (uint256[] memory amounts);

    /// @notice performs chained getAmountOut calculations on any number of pairs
    /// @param amountIn amount of tokenIn
    /// @param tokenIn address of the token going in
    /// @param tokenOut address of the token coming out
    /// @return amount uint amount out
    /// @return stable if the curve used is stable or not
    function getAmountOut(
        uint256 amountIn,
        address tokenIn,
        address tokenOut
    ) external view returns (uint256 amount, bool stable);

    /// @notice performs calculations to determine the expected state when adding liquidity
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @return amountA amount of tokenA added
    /// @return amountB amount of tokenB added
    /// @return liquidity liquidity value added
    function quoteAddLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired
    )
        external
        view
        returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param liquidity liquidity value to remove
    /// @return amountA amount of tokenA removed
    /// @return amountB amount of tokenB removed
    function quoteRemoveLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 liquidity
    ) external view returns (uint256 amountA, uint256 amountB);

    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @param amountAMin slippage for tokenA calculated from this param
    /// @param amountBMin slippage for tokenB calculated from this param
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @param token the address of token
    /// @param stable if the pair is using the stable curve
    /// @param amountTokenDesired desired amount for token
    /// @param amountTokenMin slippage for token
    /// @param amountETHMin minimum amount of ETH added (slippage)
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of the token used
    /// @return amountETH amount of ETH used
    /// @return liquidity amount of liquidity minted
    function addLiquidityETH(
        address token,
        bool stable,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param amountADesired amount of tokenA desired to be added
    /// @param amountBDesired amount of tokenB desired to be added
    /// @param amountAMin slippage for tokenA calculated from this param
    /// @param amountBMin slippage for tokenB calculated from this param
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidityAndStake(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

    /// @notice adds liquidity to a legacy pair using ETH, and stakes it into a gauge on "to's" behalf
    /// @param token the address of token
    /// @param stable if the pair is using the stable curve
    /// @param amountTokenDesired amount of token to be used
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    /// @return liquidity amount of liquidity minted
    function addLiquidityETHAndStake(
        address token,
        bool stable,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountA, uint256 amountB, uint256 liquidity);
    /// @param tokenA the address of tokenA
    /// @param tokenB the address of tokenB
    /// @param stable if the pair is using the stable curve
    /// @param liquidity amount of LP tokens to remove
    /// @param amountAMin slippage of tokenA
    /// @param amountBMin slippage of tokenB
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountA amount of tokenA used
    /// @return amountB amount of tokenB used
    function removeLiquidity(
        address tokenA,
        address tokenB,
        bool stable,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);
    /// @param token address of the token
    /// @param stable if the pair is using the stable curve
    /// @param liquidity liquidity tokens to remove
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of token used
    /// @return amountETH amount of ETH used
    function removeLiquidityETH(
        address token,
        bool stable,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);
    /// @param amountIn amount to send ideally
    /// @param amountOutMin slippage of amount out
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        route[] memory routes,
        address to,
        uint deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactETHForTokens(
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);
    /// @param amountOut amount of tokens to get out
    /// @param amountInMax max amount of tokens to put in to achieve amountOut (slippage)
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapTokensForExactETH(
        uint amountOut,
        uint amountInMax,
        route[] calldata routes,
        address to,
        uint deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountIn amount of tokens to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
    /// @param amountOut exact amount out or revert
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    /// @return amounts amounts returned
    function swapETHForExactTokens(
        uint amountOut,
        route[] calldata routes,
        address to,
        uint deadline
    ) external payable returns (uint256[] memory amounts);

    /// @param amountIn token amount to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external;

    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external payable;

    /// @param amountIn token amount to swap
    /// @param amountOutMin slippage of token
    /// @param routes the hops the swap should take
    /// @param to the address the liquidity tokens should be minted to
    /// @param deadline timestamp deadline
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        route[] calldata routes,
        address to,
        uint256 deadline
    ) external;

    /// @notice **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens)****
    /// @param token address of the token
    /// @param stable if the swap curve is stable
    /// @param liquidity liquidity value (lp tokens)
    /// @param amountTokenMin slippage of token
    /// @param amountETHMin slippage of ETH
    /// @param to address to send to
    /// @param deadline timestamp deadline
    /// @return amountToken amount of token received
    /// @return amountETH amount of ETH received
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        bool stable,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "evmVersion": "paris",
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_manager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"Bonds","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Manager","outputs":[{"internalType":"contract IManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OS","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Staking","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_finalBuyTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_finalSellTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","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":"value","type":"uint256"}],"name":"approve","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":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newFee","type":"uint256"}],"name":"downSellingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializePair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueNative","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"_isExcluded","type":"bool"}],"name":"setIsExcludedFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_initialized","type":"bool"}],"name":"setIsInitialized","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"marketingFee","type":"uint256"}],"name":"setMarketingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"setPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"setRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTax","type":"uint256"}],"name":"setSwapThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000000290185f2ccf84fc1812bb22da99d07f508f1c34

-----Decoded View---------------
Arg [0] : _manager (address): 0x0290185f2cCF84Fc1812BB22Da99D07F508f1C34

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000290185f2ccf84fc1812bb22da99d07f508f1c34