ETH Price: $3,277.34 (-0.68%)

Token

Deployyyyer Dog (DDOG)
 

Overview

Max Total Supply

420,690,000,000 DDOG

Holders

152

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-

Other Info

Token Contract (WITH 18 Decimals)

Balance
0.000000000000000001 DDOG

Value
$0.00
0xf38df3da38c5a25df377d8242652fd2568eec867
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x2eD7d468...BA3F547a3
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
TokenDiamond

Compiler Version
v0.8.23+commit.f704f362

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion
File 1 of 10 : TokenDiamond.sol
// 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 {}
}

File 2 of 10 : IDiamondCut.sol
// 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);
}

File 3 of 10 : IDiamondLoupe.sol
// 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_);
}

File 4 of 10 : IERC165.sol
// 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);
}

File 5 of 10 : IERC173.sol
// 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;
}

File 6 of 10 : IERC20.sol
// 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);
}

File 7 of 10 : INewToken.sol
// 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);
}

File 8 of 10 : IPresale.sol
// 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;
}

File 9 of 10 : LibAppStorage.sol
// 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();
        _;
    }  
    
}

File 10 of 10 : LibDiamond.sol
// 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);
    }
}

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

Contract Security Audit

Contract ABI

[{"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"}]

608060405234801561001057600080fd5b50604051610f8f380380610f8f83398101604081905261002f91610ad0565b80516001600160a01b031661004357600080fd5b6040805160008082526020820190925261005e9184916103e3565b80516100699061057f565b7f699d9daa71b280d05a152715774afa0a81a312594b2d731d6b0b2552b7d6f69f8054600160ff1991821681179092557f65d510a5d8f7ef134ec444f7f34ee808c8eeb5177cdfd16be0c40fe1ab43369580548216831790557f5622121b47b8cd0120c4efe45dd5483242f54a3d49bd7679be565d47694918c380548216831790557f70e699e155a5f76c229c88a52614e4bfee4370d1adc9e274e24a68bd8444e5cd8054821690921790915560178054336001600160a01b031991821617909155600b8054831690556306fdde0360e01b6000908152600080516020610f6f83398151915260208181527fb50e9547bcc8bcab18569462620f0d59a4acc6a75595277950eebc52116a02bf54601b805460609290921c91861691909117905560408601516019805486166001600160a01b0392831617905560a0870151600c5561014087015160218190556022556101608701516023556101c087015160345561018087015160248190556025556101a087015160265560e0870151601e55610100870151601f556101208701518255601d9390935560288054601296169590951790945560808501516032805460ff60b81b1916600160b81b9215159290920291909117905592840151601680549093169116179055610280820151602a906102549082610cfc565b506102a0820151602b906102689082610cfc565b5060c082015161028090670de0b6b3a7640000610dd1565b60295561026082015161029b90670de0b6b3a7640000610dd1565b602d556102408201516102b690670de0b6b3a7640000610dd1565b602e556032805460ff60b01b1916600160b01b1790556101e08201516029546064916102e191610dd1565b6102eb9190610dee565b602f5561020082015160295460649161030391610dd1565b61030d9190610dee565b6030556101e0820151606414801561032a57508161020001516064145b1561033d576032805460ff60b01b191690555b7f3e470cf1ec3767d0209f5128c840997ff9b70dfe0da263b3f94eb114a05d9327826101e00151836102000151604051610381929190918252602082015260400190565b60405180910390a160295430600081815260146020908152604080832085905551938452919290917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3506102200151602c5550610e88565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131e54600080516020610f6f8339815191529061ffff8116908190600090600716156104405750600381901c60009081526001840160205260409020545b60005b87518110156104c3576104b683838a848151811061046357610463610e10565b6020026020010151600001518b858151811061048157610481610e10565b6020026020010151602001518c868151811061049f5761049f610e10565b60200260200101516040015161060260201b60201c565b9093509150600101610443565b508282146104df5760028401805461ffff191661ffff84161790555b600782161561050157600382901c600090815260018501602052604090208190555b6001600160a01b038616156105425760405162461bcd60e51b81526020600482015260026024820152616c3160f01b60448201526064015b60405180910390fd5b8451156105765760405162461bcd60e51b8152602060048201526002602482015261361960f11b6044820152606401610539565b50505050505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c132080546001600160a01b031981166001600160a01b03848116918217909355604051600080516020610f6f833981519152939092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b60008080600080516020610f6f8339815191529050600084511161064d5760405162461bcd60e51b81526020600482015260026024820152616c3360f01b6044820152606401610539565b600085600281111561066157610661610e26565b036107965761069086604051806040016040528060028152602001611b0d60f21b8152506107cf60201b60201c565b60005b84518110156107905760008582815181106106b0576106b0610e10565b6020908102919091018101516001600160e01b03198116600090815291859052604090912054909150606081901c156107105760405162461bcd60e51b81526020600482015260026024820152616c3560f01b6044820152606401610539565b6001600160e01b031980831660008181526020879052604090206001600160601b031960608d901b168e17905560e060058e901b811692831c199c909c1690821c179a8190036107745760038c901c600090815260018601602052604081209b909b555b8b61077e81610e3c565b9c505060019093019250610693915050565b506107c3565b60405162461bcd60e51b8152602060048201526002602482015261361b60f11b6044820152606401610539565b50959694955050505050565b813b81816107f05760405162461bcd60e51b81526004016105399190610e55565b50505050565b634e487b7160e01b600052604160045260246000fd5b6040516102c081016001600160401b038111828210171561082f5761082f6107f6565b60405290565b604051606081016001600160401b038111828210171561082f5761082f6107f6565b604051601f8201601f191681016001600160401b038111828210171561087f5761087f6107f6565b604052919050565b60006001600160401b038211156108a0576108a06107f6565b5060051b60200190565b80516001600160a01b03811681146108c157600080fd5b919050565b805180151581146108c157600080fd5b60005b838110156108f15781810151838201526020016108d9565b50506000910152565b600082601f83011261090b57600080fd5b81516001600160401b03811115610924576109246107f6565b610937601f8201601f1916602001610857565b81815284602083860101111561094c57600080fd5b61095d8260208301602087016108d6565b949350505050565b60006102c0828403121561097857600080fd5b61098061080c565b905061098b826108aa565b8152610999602083016108aa565b60208201526109aa604083016108aa565b60408201526109bb606083016108aa565b60608201526109cc608083016108c6565b608082015260a0828101519082015260c0808301519082015260e08083015190820152610100808301519082015261012080830151908201526101408083015190820152610160808301519082015261018080830151908201526101a080830151908201526101c080830151908201526101e080830151908201526102008083015190820152610220808301519082015261024080830151908201526102608083015190820152610280808301516001600160401b0380821115610a8f57600080fd5b610a9b868387016108fa565b838501526102a0925082850151915080821115610ab757600080fd5b50610ac4858286016108fa565b82840152505092915050565b60008060408385031215610ae357600080fd5b82516001600160401b0380821115610afa57600080fd5b818501915085601f830112610b0e57600080fd5b81516020610b23610b1e83610887565b610857565b82815260059290921b84018101918181019089841115610b4257600080fd5b8286015b84811015610c4057805186811115610b5d57600080fd5b87016060818d03601f19011215610b7357600080fd5b610b7b610835565b610b868683016108aa565b8152604082015160038110610b9a57600080fd5b81870152606082015188811115610bb057600080fd5b8083019250508c603f830112610bc557600080fd5b85820151610bd5610b1e82610887565b81815260059190911b830160400190878101908f831115610bf557600080fd5b6040850194505b82851015610c2b5784516001600160e01b031981168114610c1c57600080fd5b82529388019390880190610bfc565b60408401525050845250918301918301610b46565b5091880151919650909350505080821115610c5a57600080fd5b50610c6785828601610965565b9150509250929050565b600181811c90821680610c8557607f821691505b602082108103610ca557634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115610cf7576000816000526020600020601f850160051c81016020861015610cd45750805b601f850160051c820191505b81811015610cf357828155600101610ce0565b5050505b505050565b81516001600160401b03811115610d1557610d156107f6565b610d2981610d238454610c71565b84610cab565b602080601f831160018114610d5e5760008415610d465750858301515b600019600386901b1c1916600185901b178555610cf3565b600085815260208120601f198616915b82811015610d8d57888601518255948401946001909101908401610d6e565b5085821015610dab5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052601160045260246000fd5b8082028115828204841417610de857610de8610dbb565b92915050565b600082610e0b57634e487b7160e01b600052601260045260246000fd5b500490565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052602160045260246000fd5b600060018201610e4e57610e4e610dbb565b5060010190565b6020815260008251806020840152610e748160408501602087016108d6565b601f01601f19169190910160400192915050565b60d980610e966000396000f3fe608060405236600a57005b600080356001600160e01b03191681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819060601c8060805760405162461bcd60e51b8152602060048201526002602482015261543160f01b604482015260640160405180910390fd5b3660008037600080366000845af43d6000803e808015609e573d6000f35b3d6000fdfea26469706673582212201b4f390c6be3830740d57b0feba9c80f98b4259e3f8a0c8bd6de38891ee92bef64736f6c63430008170033c8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000003600000000000000000000000005a99bf51b70636e60bb825e79b3ca0b3cec8b1fa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000bf2fde38b000000000000000000000000000000000000000000000000000000008da5cb5b0000000000000000000000000000000000000000000000000000000044ee3a1c000000000000000000000000000000000000000000000000000000004839c8b30000000000000000000000000000000000000000000000000000000048c54b9d000000000000000000000000000000000000000000000000000000000d0da2d4000000000000000000000000000000000000000000000000000000005c89dfe1000000000000000000000000000000000000000000000000000000000b45260e00000000000000000000000000000000000000000000000000000000af66394d00000000000000000000000000000000000000000000000000000000dde070e80000000000000000000000000000000000000000000000000000000020ffb26d000000000000000000000000000000000000000000000000000000000000000000000000000000009c84288cb2c0fcad30f031ac1d4b1633ef994c63000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c00000000000000000000000000000000000000000000000000000000adfca15e000000000000000000000000000000000000000000000000000000007a0ed6270000000000000000000000000000000000000000000000000000000001ffc9a70000000000000000000000000000000000000000000000000000000000000000000000000000000076bfec03547673b84223d9fb4c02eb20ec021e0700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001006fdde030000000000000000000000000000000000000000000000000000000095d89b4100000000000000000000000000000000000000000000000000000000313ce5670000000000000000000000000000000000000000000000000000000018160ddd0000000000000000000000000000000000000000000000000000000070a082310000000000000000000000000000000000000000000000000000000023b872dd00000000000000000000000000000000000000000000000000000000a9059cbb00000000000000000000000000000000000000000000000000000000095ea7b300000000000000000000000000000000000000000000000000000000dd62ed3e00000000000000000000000000000000000000000000000000000000ccec37160000000000000000000000000000000000000000000000000000000078f8484b00000000000000000000000000000000000000000000000000000000db7c4dda000000000000000000000000000000000000000000000000000000001bbd3a240000000000000000000000000000000000000000000000000000000087fc38b000000000000000000000000000000000000000000000000000000000b5660a1800000000000000000000000000000000000000000000000000000000b39956360000000000000000000000000000000000000000000000000000000000000000000000000000000018a0639067cf4f0ca04877ce1c2378d01f5d846600000000000000000000000018a0639067cf4f0ca04877ce1c2378d01f5d8466000000000000000000000000f992610355f3c5fcc4bc300b0b9eb5b5ff037d2c0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000016345785d8a0000000000000000000000000000000000000000000000000000000000003b9aca000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000003c00000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000098968000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000002c00000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000b5375706572204e6569726f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006534e4549524f0000000000000000000000000000000000000000000000000000

Deployed Bytecode

0x608060405236600a57005b600080356001600160e01b03191681527fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131c6020819052604090912054819060601c8060805760405162461bcd60e51b8152602060048201526002602482015261543160f01b604482015260640160405180910390fd5b3660008037600080366000845af43d6000803e808015609e573d6000f35b3d6000fdfea26469706673582212201b4f390c6be3830740d57b0feba9c80f98b4259e3f8a0c8bd6de38891ee92bef64736f6c63430008170033

Loading...
Loading
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.