Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
/*********************************************************************************************\
* Deployyyyer: https://deployyyyer.io
* Twitter: https://x.com/deployyyyer
* Telegram: https://t.me/Deployyyyer
/*********************************************************************************************/
pragma solidity ^0.8.23;

import { LibDiamond } from "../libraries/LibDiamond.sol";
import { IDiamondCut } from "../interfaces/IDiamondCut.sol";

//import "../libraries/LibDiamond.sol";
import "../interfaces/IDiamondLoupe.sol";
import "../interfaces/IDiamondCut.sol";
import "../interfaces/IERC173.sol";
import "../interfaces/IERC165.sol";
import "../interfaces/IERC20.sol";
import {AppStorage} from "../libraries/LibAppStorage.sol";
import { INewToken, IUniswapV2Router02 } from "../interfaces/INewToken.sol";
//import { NewTokenFacet } from "./NewTokenFacet.sol";
//import "hardhat/console.sol";

/// @title TokenDiamond 
/// @notice Diamond Proxy for a launched token
/// @dev 
contract TokenDiamond { 
    AppStorage internal s;
    event Transfer(address indexed from, address indexed to, uint256 value);
    //event Approval(address indexed owner, address indexed spender, uint256 value);
    event IncreasedLimits(uint256 maxWallet, uint256 maxTx);

    /// @notice Constructor of Diamond Proxy for a launched token
    constructor(IDiamondCut.FacetCut[] memory _diamondCut, INewToken.InitParams memory params) {
        require(params.owner != address(0));
        LibDiamond.diamondCut(_diamondCut, address(0), new bytes(0));
        LibDiamond.setContractOwner(params.owner);

        LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();

        // adding ERC165 data
        ds.supportedInterfaces[type(IERC165).interfaceId] = true;
        //ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;
        ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;
        ds.supportedInterfaces[type(IERC173).interfaceId] = true;
        ds.supportedInterfaces[type(IERC20).interfaceId] = true;

        //init appStorage   
        //s.deployyyyer = msg.sender;
        //deployerWallet is always deployyyyer launcher
        s.deployyyyerCa = payable(msg.sender);
        s.isParent = false; 
        s.tokenFacet = address(bytes20(ds.facets[IERC20.name.selector]));

        s.stakingFacet = params.stakingFacet;
        s.minLiq = params.minLiq;
        s.taxBuy = params.maxBuyTax; //20%
        s.maxBuyTax = params.maxBuyTax;
        s.minBuyTax = params.minBuyTax;
        s.lpTax = params.lpTax;
        s.taxSell = params.maxSellTax; //20%
        s.maxSellTax = params.maxSellTax;
        s.minSellTax = params.minSellTax;
        
        s.initTaxType = params.initTaxType;
        s.initInterval = params.initInterval;
        s.countInterval = params.countInterval;

        // Reduction Rules
        s.buyCount = 0; 
    

        // Token Information
        s.decimals = 18;

        s.isFreeTier = params.isFreeTier;
        s.taxWallet = payable(params.taxWallet);
        
        s.name = params.name;
        s.symbol = params.symbol;
        s.tTotal = params.supply*10**18;

        // Contract Swap Rules            
        s.taxSwapThreshold = params.taxSwapThreshold*10**18; //0.1%
        s.maxTaxSwap = params.maxSwap*10**18; //1%
        s.walletLimited = true;
        
        
        s.maxWallet = s.tTotal * params.maxWallet / 100;  //1% (allow 1 - 100)
        s.maxTx = s.tTotal * params.maxTx / 100;
        if (params.maxWallet == 100 && params.maxTx == 100) {
            s.walletLimited = false;
        }
        emit IncreasedLimits(params.maxWallet, params.maxTx);
        s.balances[address(this)] = s.tTotal;
        emit Transfer(address(0), address(this), s.tTotal);

        s.preventSwap = params.preventSwap;

        //s.uniswapV2Router = IUniswapV2Router02(params.v2router);
        //s.allowances[address(this)][address(s.uniswapV2Router)] = s.tTotal;
        //emit Approval(address(this), address(s.uniswapV2Router), s.tTotal);

    }  

    /// @notice fallback
    // Find facet for function that is called and execute the
    // function if a facet is found and return any value.
    fallback() external payable {
        LibDiamond.DiamondStorage storage ds;
        bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;
        // get diamond storage
        assembly {
            ds.slot := position
        }
        // get facet from function selector
        address facet = address(bytes20(ds.facets[msg.sig]));
        //require(facet != address(0), "T1");
        require(facet != address(0), "T1");
        // Execute external function from facet using delegatecall and return any value.
        assembly {
            // copy function selector and any arguments
            calldatacopy(0, 0, calldatasize())
            // execute function call using the facet
            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
            // get any return value
            returndatacopy(0, 0, returndatasize())
            // return any return value or error back to the caller
            switch result
                case 0 {
                    revert(0, returndatasize())
                }
                default {
                    return(0, returndatasize())
                }
        }
    }
    
    /// @notice receive eth
    receive() external payable {}
}

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

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

interface IDiamondCut {
    enum FacetCutAction {Add, Replace, Remove}
    // Add=0, Replace=1, Remove=2

    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }

    /// @notice Add/replace/remove any number of functions and optionally execute
    ///         a function with delegatecall
    /// @param _diamondCut Contains the facet addresses and function selectors
    /// @param _init The address of the contract or facet to execute _calldata
    /// @param _calldata A function call, including function selector and arguments
    ///                  _calldata is executed with delegatecall on _init
    function diamondCut(
        FacetCut[] calldata _diamondCut,
        address _init,
        bytes calldata _calldata
    ) external;

    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
}

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

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

// A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds
interface IDiamondLoupe {
    /// These functions are expected to be called frequently
    /// by tools.

    struct Facet {
        address facetAddress;
        bytes4[] functionSelectors;
    }

    /// @notice Gets all facet addresses and their four byte function selectors.
    /// @return facets_ Facet
    function facets() external view returns (Facet[] memory facets_);

    /// @notice Gets all the function selectors supported by a specific facet.
    /// @param _facet The facet address.
    /// @return facetFunctionSelectors_
    function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);

    /// @notice Get all the facet addresses used by a diamond.
    /// @return facetAddresses_
    function facetAddresses() external view returns (address[] memory facetAddresses_);

    /// @notice Gets the facet that supports the given selector.
    /// @dev If facet is not found return address(0).
    /// @param _functionSelector The function selector.
    /// @return facetAddress_ The facet address.
    function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);
}

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

interface IERC165 {
    /// @notice Query if a contract implements an interface
    /// @param interfaceId The interface identifier, as specified in ERC-165
    /// @dev Interface identification is specified in ERC-165. This function
    ///  uses less than 30,000 gas.
    /// @return `true` if the contract implements `interfaceID` and
    ///  `interfaceID` is not 0xffffffff, `false` otherwise
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

/// @title ERC-173 Contract Ownership Standard
///  Note: the ERC-165 identifier for this interface is 0x7f5828d0
/* is ERC165 */
interface IERC173 {
    /// @dev This emits when ownership of a contract changes.
    //event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /// @notice Get the address of the owner
    /// @return owner_ The address of the owner.
    function owner() external view returns (address owner_);

    /// @notice Set the address of the new owner of the contract
    /// @dev Set _newOwner to address(0) to renounce any ownership.
    /// @param _newOwner The address of the new owner of the contract
    function transferOwnership(address _newOwner) external;
}

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


interface IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address _owner) external view returns (uint256 balance);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool success);

    function transfer(address _to, uint256 _value) external returns (bool success);

    function approve(address _spender, uint256 _value) external returns (bool success);

    function allowance(address _owner, address _spender) external view returns (uint256 remaining);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import { IPresale} from "./IPresale.sol";

interface INewToken {
    struct InitParams {
        address owner;
        address taxWallet;
        address stakingFacet;
        address v2router;
        bool isFreeTier;
        uint256 minLiq; 
        uint256 supply;
        uint256 initTaxType; //0-time,1-buyCount,2-hybrid
        uint256 initInterval; //seconds 0-1 hour(if 1m: 1m, 3m, 6m, 10m)
        uint256 countInterval; //0-100 
        uint256  maxBuyTax; //40%
        uint256  minBuyTax; //0
        uint256  maxSellTax; //40%
        uint256  minSellTax; //0
        uint256  lpTax; //0-90 of buy or sell tax
        uint256 maxWallet;
        uint256 maxTx;
        uint256 preventSwap;
        uint256 maxSwap;
        uint256 taxSwapThreshold;
        string  name;
        string  symbol;
    }
    
    struct TeamParams {
        address team1;
        uint256 team1p; 
        uint256 cliffPeriod; 
        uint256 vestingPeriod;
        bool isAdd;
    }

	function rescueERC20(address _address) external;
	function increaseLimits(uint256 maxwallet, uint256 maxtx) external;
	function startTrading(uint256 lockPeriod, bool shouldBurn, address router) external;
    //require trading and presale not started
    function addPresale(address presale, uint256 percent, IPresale.PresaleParams memory newdetails) external;
    //require caller to be presale address
    function finPresale() external;
    function refPresale() external;
    //requires presale not started and trading not started
    function addTeam(TeamParams memory params) external;
    //what if we remove team out from init?
}

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

}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    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);
}

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

interface IPresale {
    struct PresaleParams {
            address owner;
            address token;
            uint256 softcap;
            uint256 hardcap;
            uint256 startTs;
            uint256 finishTs;
            uint256 duration;
            uint256 liqPercent;
            uint256 cliffPeriod;
            uint256 vestingPeriod;
            uint256 status;
            uint256 sold;
            uint256 maxEth;
            uint256 maxBag;
            uint256 fee;
    }

    function transferOwnership(address _newOwner) external;
    function owner() external view returns (address);
    function rescueERC20(address _address) external;
    function setupPresale(PresaleParams memory params) external;
    function buyTokens(uint256 _amount) external payable;
    //should we offer or force token vesting??
    function claimTokens() external;
    function getRefund() external;
    function getPresaleDetails() external view returns(PresaleParams memory); 
    function finishPresale() external; 
    function claimEth() external;
    function getClaimableTokens(address user) external view returns(uint256,uint256,uint256,uint256);
    function refundPresale() external;
}

// SPDX-License-Identifier: MIT
/*********************************************************************************************\
* Deployyyyer: https://deployyyyer.io
* Twitter: https://x.com/deployyyyer
* Telegram: https://t.me/Deployyyyer
/*********************************************************************************************/
pragma solidity ^0.8.23;
import {LibDiamond} from "./LibDiamond.sol";
//import {LibMeta} from "./LibMeta.sol";
import {IUniswapV2Factory, IUniswapV2Router02} from "../interfaces/INewToken.sol";



struct AppStorage {
    mapping(address => bool) validRouters; //parentOnly
    mapping(address => bool) allowedTokens; //parentOnly
    //this should be bool too
    mapping(address => address) launchedTokens; //parentOnly
    mapping(address => address) launchedPresale; //parentOnly
    //cost of launch, cost of promo, cost of setting socials is 2xpromoCostEth
    uint256 ethCost; //parentOnly
    uint256 deployyyyerCost; //parentOnly
    uint256 promoCostEth; //parentOnly
    uint256 promoCostDeployyyyer; //parentOnly
    address bridge; //parentOnly

    //mapping of user address to score
    mapping(address => uint256) myScore; //parentOnly

    //+1 for launch, +5 for liquidity add, +50 for lp burn, -100 for lp retrieve
    uint256 cScore; //cScore is transferred with ownership, cScore is deducted on lp retrieve

    
    //address deployyyyer;
    bool isParent;
    uint256 minLiq;
    //this can be a map with share and clain in a structure
    mapping(address => uint256) teamShare;
    mapping(address => uint256) teamClaim;
    
    uint256 teamBalance;

    uint256 cliffPeriod; //min 30days
    uint256 vestingPeriod;//min 1day max 10000 days avg 30days.


    mapping(address => bool)  isExTxLimit; //is excluded from transaction limit
    mapping(address => bool)  isExWaLimit; //is excluded from wallet limit
    mapping (address => uint256)  balances; //ERC20 balance
    mapping (address => mapping (address => uint256))  allowances; //ERC20 balance

    address payable taxWallet; //tax wallet for the token
    address payable deployyyyerCa; //deployyyyer contract address
    address payable stakingContract; //address of staking contract for the token
    address stakingFacet; //facet address, used to launch a staking pool
    address presaleFacet; //facet address, used to launch a presale
    address tokenFacet; //facet address, used to launch a ERC20 token
    uint256 stakingShare; //share of tax sent to its staking pool
    
    
    // Reduction Rules
    uint256  buyCount; 

    uint256 initTaxType; //0-time,1-buyCount,2-hybrid,3-none
    //interval*1, lastIntEnd+(interval*2), lastIntEnd+(interval*3)
    uint256 initInterval; //seconds 0-1 hour(if 1m: 1m, 3m, 6m, 10m)
    uint256 countInterval; //0-100 

    //current taxes
    uint256  taxBuy; 
    uint256  maxBuyTax; //40%
    uint256  minBuyTax; //0

    uint256  taxSell; 
    uint256  maxSellTax; //40%
    uint256  minSellTax; //0
    
    


    uint256  tradingOpened;

    // Token Information
    uint8   decimals;
    uint256   tTotal;
    string   name;
    string   symbol;

    // Contract Swap Rules 
    uint256 preventSwap; //50            
    uint256  taxSwapThreshold; //0.1%
    uint256  maxTaxSwap; //1%
    uint256  maxWallet; //1%
    uint256  maxTx;

    IUniswapV2Router02  uniswapV2Router;
    address  uniswapV2Pair;
    
    bool  tradingOpen; //true if liquidity pool is created
    bool  inSwap;
    bool  walletLimited;
    bool isFreeTier;
    bool isBurnt;
    bool isRetrieved;
    uint256 lockPeriod;
    
    //buy back tax calculations
    uint256 lpTax; //0-50 percent of tax amount 
    uint256 halfLp;
    uint256 lastSwap;

    uint256 presaleTs;
    uint256 presaleSt;
    address presale;

}

/*
library LibAppStorage {
    function diamondStorage() internal pure returns (AppStorage storage ds) {
        assembly {
            ds.slot := 0
        }
    }

    function abs(int256 x) internal pure returns (uint256) {
        return uint256(x >= 0 ? x : -x);
    }
}
*/


contract Modifiers {
    AppStorage internal s;

    modifier onlyOwner() {
        LibDiamond.enforceIsContractOwner();
        _;
    }  
    
}

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

/*********************************************************************************************\
* Authors: Nick Mudge <[email protected]> (https://twitter.com/mudgen), 
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/*********************************************************************************************/
import { IDiamondCut } from "../interfaces/IDiamondCut.sol";

library LibDiamond {
    bytes32 constant DIAMOND_STORAGE_POSITION = keccak256("diamond.standard.diamond.storage");

    struct DiamondStorage {
        // maps function selectors to the facets that execute the functions.
        // and maps the selectors to their position in the selectorSlots array.
        // func selector => address facet, selector position
        mapping(bytes4 => bytes32) facets;
        // array of slots of function selectors.
        // each slot holds 8 function selectors.
        mapping(uint256 => bytes32) selectorSlots;
        // The number of function selectors in selectorSlots
        uint16 selectorCount;
        // Used to query if a contract implements an interface.
        // Used to implement ERC-165.
        mapping(bytes4 => bool) supportedInterfaces;
        // owner of the contract
        address contractOwner;
    }

    function diamondStorage() internal pure returns (DiamondStorage storage ds) {
        bytes32 position = DIAMOND_STORAGE_POSITION;
        assembly {
            ds.slot := position
        }
    }

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

    function setContractOwner(address _newOwner) internal {
        DiamondStorage storage ds = diamondStorage();
        address previousOwner = ds.contractOwner;
        ds.contractOwner = _newOwner;
        emit OwnershipTransferred(previousOwner, _newOwner);
    }

    function contractOwner() internal view returns (address contractOwner_) {
        contractOwner_ = diamondStorage().contractOwner;
    }

    function enforceIsContractOwner() internal view {
        require(msg.sender == diamondStorage().contractOwner, "l0");
    }

    //event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);

    //bytes32 constant CLEAR_ADDRESS_MASK = bytes32(uint256(0xffffffffffffffffffffffff));
    bytes32 constant CLEAR_SELECTOR_MASK = bytes32(uint256(0xffffffff << 224));

    // Internal function version of diamondCut
    // This code is almost the same as the external diamondCut,
    // except it is using 'Facet[] memory _diamondCut' instead of
    // 'Facet[] calldata _diamondCut'.
    // The code is duplicated to prevent copying calldata to memory which
    // causes an error for a two dimensional array.
    // also removed action on _calldata and _init is always address(0)
    // maintained same old signature
    function diamondCut(
        IDiamondCut.FacetCut[] memory _diamondCut,
        address _init,
        bytes memory _calldata
    ) internal {
        DiamondStorage storage ds = diamondStorage();
        uint256 originalSelectorCount = ds.selectorCount;
        uint256 selectorCount = originalSelectorCount;
        bytes32 selectorSlot;
        // Check if last selector slot is not full
        // "selectorCount & 7" is a gas efficient modulo by eight "selectorCount % 8" 
        if (selectorCount & 7 > 0) {
            // get last selectorSlot
            // "selectorSlot >> 3" is a gas efficient division by 8 "selectorSlot / 8"
            selectorSlot = ds.selectorSlots[selectorCount >> 3];
        }
        // loop through diamond cut
        for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {
            (selectorCount, selectorSlot) = addReplaceRemoveFacetSelectors(
                selectorCount,
                selectorSlot,
                _diamondCut[facetIndex].facetAddress,
                _diamondCut[facetIndex].action,
                _diamondCut[facetIndex].functionSelectors
            );
        }
        if (selectorCount != originalSelectorCount) {
            ds.selectorCount = uint16(selectorCount);
        }
        // If last selector slot is not full
        // "selectorCount & 7" is a gas efficient modulo by eight "selectorCount % 8" 
        if (selectorCount & 7 > 0) {
            // "selectorSlot >> 3" is a gas efficient division by 8 "selectorSlot / 8"
            ds.selectorSlots[selectorCount >> 3] = selectorSlot;
        }
        //emit DiamondCut(_diamondCut, _init, _calldata);
        //initializeDiamondCut(_init, _calldata);
        require(_init == address(0), "l1");
        require(_calldata.length == 0, "l2");
    }

    //supports only add, maintaining lib fn name
    function addReplaceRemoveFacetSelectors(
        uint256 _selectorCount,
        bytes32 _selectorSlot,
        address _newFacetAddress,
        IDiamondCut.FacetCutAction _action,
        bytes4[] memory _selectors
    ) internal returns (uint256, bytes32) {
        DiamondStorage storage ds = diamondStorage();
        require(_selectors.length > 0, "l3");
        if (_action == IDiamondCut.FacetCutAction.Add) {
            enforceHasContractCode(_newFacetAddress, "l4");
            for (uint256 selectorIndex; selectorIndex < _selectors.length; selectorIndex++) {
                bytes4 selector = _selectors[selectorIndex];
                bytes32 oldFacet = ds.facets[selector];
                require(address(bytes20(oldFacet)) == address(0), "l5");
                // add facet for selector
                ds.facets[selector] = bytes20(_newFacetAddress) | bytes32(_selectorCount);
                // "_selectorCount & 7" is a gas efficient modulo by eight "_selectorCount % 8" 
                uint256 selectorInSlotPosition = (_selectorCount & 7) << 5;
                // clear selector position in slot and add selector
                _selectorSlot = (_selectorSlot & ~(CLEAR_SELECTOR_MASK >> selectorInSlotPosition)) | (bytes32(selector) >> selectorInSlotPosition);
                // if slot is full then write it to storage
                if (selectorInSlotPosition == 224) {
                    // "_selectorSlot >> 3" is a gas efficient division by 8 "_selectorSlot / 8"
                    ds.selectorSlots[_selectorCount >> 3] = _selectorSlot;
                    _selectorSlot = 0;
                }
                _selectorCount++;
            }
        } 
        else {
            revert("l6");
        }
        return (_selectorCount, _selectorSlot);
    }

    function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {
        uint256 contractSize;
        assembly {
            contractSize := extcodesize(_contract)
        }
        require(contractSize > 0, _errorMessage);
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"address","name":"facetAddress","type":"address"},{"internalType":"enum IDiamondCut.FacetCutAction","name":"action","type":"uint8"},{"internalType":"bytes4[]","name":"functionSelectors","type":"bytes4[]"}],"internalType":"struct IDiamondCut.FacetCut[]","name":"_diamondCut","type":"tuple[]"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"taxWallet","type":"address"},{"internalType":"address","name":"stakingFacet","type":"address"},{"internalType":"address","name":"v2router","type":"address"},{"internalType":"bool","name":"isFreeTier","type":"bool"},{"internalType":"uint256","name":"minLiq","type":"uint256"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"uint256","name":"initTaxType","type":"uint256"},{"internalType":"uint256","name":"initInterval","type":"uint256"},{"internalType":"uint256","name":"countInterval","type":"uint256"},{"internalType":"uint256","name":"maxBuyTax","type":"uint256"},{"internalType":"uint256","name":"minBuyTax","type":"uint256"},{"internalType":"uint256","name":"maxSellTax","type":"uint256"},{"internalType":"uint256","name":"minSellTax","type":"uint256"},{"internalType":"uint256","name":"lpTax","type":"uint256"},{"internalType":"uint256","name":"maxWallet","type":"uint256"},{"internalType":"uint256","name":"maxTx","type":"uint256"},{"internalType":"uint256","name":"preventSwap","type":"uint256"},{"internalType":"uint256","name":"maxSwap","type":"uint256"},{"internalType":"uint256","name":"taxSwapThreshold","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"internalType":"struct INewToken.InitParams","name":"params","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxWallet","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxTx","type":"uint256"}],"name":"IncreasedLimits","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":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"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

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

0x608060405236600a57005b600080356001600160e01b03191681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819060601c8060805760405162461bcd60e51b8152602060048201526002602482015261543160f01b604482015260640160405180910390fd5b3660008037600080366000845af43d6000803e808015609e573d6000f35b3d6000fdfea26469706673582212201b4f390c6be3830740d57b0feba9c80f98b4259e3f8a0c8bd6de38891ee92bef64736f6c63430008170033