Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// dpot.io
// x.com/depot_app
// t.me/depot_app
//
//
// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

// OpenZeppelin imports
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

// Uniswap V2 Router interface
interface IUniswapV2Router {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}

// Uniswap V2 Factory interface
interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

/**
 * @title Depot
 * @dev ERC20 token
 */
contract DEPOT is IERC20, IERC20Metadata, Ownable, ReentrancyGuard {
    using Address for address payable;
    using SafeERC20 for IERC20;
    
    // Core token data
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _approvals;
    
    uint256 private _supply;
    string private _name;
    string private _symbol;
    uint8 private constant DECIMALS = 18;
    
    // Fee structure
    struct FeeConfig {
        uint256 buyFee;
        uint256 sellFee;
        uint256 transferFee;
        bool locked;
    }
    
    // Revenue distribution
    struct RevenueDistribution {
        address payable primaryWallet;
        address payable secondaryWallet;
        uint256 primaryShare; // 5000 = 50%
        uint256 secondaryShare; // 5000 = 50%
    }
    
    // Core configuration
    FeeConfig public feeStructure;
    RevenueDistribution public distribution;
    
    // Tax phase management
    bool public maxFeeReached;
    bool public launchTaxActivated;
    
    // Exemption mappings
    mapping(address => bool) private _feeExempt;
    mapping(address => bool) private _isMarketPair;
    
    // DEX integration
    IUniswapV2Router public immutable dexRouter;
    address public immutable liquidityPair;
    address public immutable nativeToken;
    
    // Trading state
    bool public tradingEnabled;
    bool public liquidityEstablished;
    uint256 public launchTimestamp;
    
    // Limit controls
    bool public limitationsActive = true;
    uint256 public maximumHolding;
    mapping(address => bool) private _limitExempt;
    
    // Fee conversion settings
    uint256 public conversionTrigger;
    uint256 private maximumConversion;
    
    // MEV and spam protection
    bool private inConversion;
    uint256 public conversionCounter;
    uint256 public lastConversionBlock;
    uint256 public maxConversionsPerBlock = 8;
    
    // Safety mechanisms
    uint256 public conversionCap;
    
    // Fee constants
    uint256 public constant MAXIMUM_FEE = 500; // 5%
    uint256 public constant FEE_DENOMINATOR = 10000; // 100%
    uint256 public constant INITIAL_BUY_FEE = 3000; // 30%
    uint256 public constant INITIAL_SELL_FEE = 3000; // 30%

    // Vesting integration
    address public constant VESTING_CONTRACT = 0xDba68f07d1b7Ca219f78ae8582C213d975c25cAf;
    
    // Access control
    modifier onlyValidAddress(address addr) {
        require(addr != address(0), "Invalid address");
        _;
    }
    
    modifier conversionLock {
        inConversion = true;
        _;
        inConversion = false;
    }
    
    // Events
    event TradingActivated(uint256 timestamp);
    event LaunchFeesActivated(uint256 buyFee, uint256 sellFee, uint256 timestamp);
    event FeeRatesModified(uint256 buyFee, uint256 sellFee, uint256 transferFee);
    event DistributionUpdated(address primaryWallet, address secondaryWallet, uint256 primaryShare, uint256 secondaryShare);
    event FeeConversionExecuted(uint256 tokensProcessed, uint256 ethGenerated);
    event FeeConfigurationLocked();
    event HoldingLimitUpdated(uint256 newLimit);
    event LimitationsDeactivated();
    event ExemptionStatusChanged(address account, bool exempt);
    event SafeguardUpdated(uint256 newConversionCap);
    event SafeguardTriggered(uint256 requestedAmount, uint256 actualAmount);
    event MaximumFeeLimitReached(uint256 timestamp, string message);
    event ConversionLimitUpdated(uint256 maxConversions);
    event LiquidityConfirmed(uint256 timestamp);
    
    /**
     * @dev Initialize token
     */
    constructor(
        string memory tokenName,
        string memory tokenSymbol,
        uint256 initialSupply,
        address primaryTaxWallet,
        address secondaryTaxWallet
    ) Ownable(msg.sender) 
      onlyValidAddress(primaryTaxWallet) 
      onlyValidAddress(secondaryTaxWallet) {
        
        _name = tokenName;
        _symbol = tokenSymbol;
        _supply = initialSupply * 10**DECIMALS;
        
        // Initialize fee structure
        feeStructure = FeeConfig({
            buyFee: 0,
            sellFee: 0,
            transferFee: 0,
            locked: false
        });
        
        // Set up revenue distribution - 50/50 split
        distribution = RevenueDistribution({
            primaryWallet: payable(primaryTaxWallet),
            secondaryWallet: payable(secondaryTaxWallet),
            primaryShare: 5000,
            secondaryShare: 5000
        });
        
        // Initialize phase tracking
        maxFeeReached = true;
        launchTaxActivated = false;
        
        // Configure DEX integration
        IUniswapV2Router router = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        dexRouter = router;
        nativeToken = router.WETH();
        
        liquidityPair = IUniswapV2Factory(router.factory()).createPair(address(this), nativeToken);
        _isMarketPair[liquidityPair] = true;
        
        // Configure fee conversion parameters
        conversionTrigger = _supply / 2000; // 0.05%
        maximumConversion = _supply / 200; // 0.5%
        
        // Set conversion safety cap
        conversionCap = _supply / 100; // 1% max per conversion
        
        // Initialize holding limit at 2%
        maximumHolding = _supply * 2 / 100;
        
        // Set fee exemptions
        _feeExempt[owner()] = true;
        _feeExempt[address(this)] = true;
        _feeExempt[address(router)] = true;
        
        // Set limit exemptions
        _limitExempt[owner()] = true;
        _limitExempt[address(this)] = true;
        _limitExempt[address(router)] = true;
        _limitExempt[liquidityPair] = true;
        _limitExempt[address(0xdead)] = true;
        _limitExempt[VESTING_CONTRACT] = true;

        _limitExempt[0xD30bD40fdb1C2d82fB4FCD4A7890EC6f7A2d5693] = true;
        _limitExempt[0x28D2D134dfd883689d2f1A8Bc1ECf1dA6043D333] = true;
        _limitExempt[0xb31c5D0130934b9F4057A594F850C2fC87a25a20] = true;
        
        // Mint total supply to owner
        _balances[owner()] = _supply;
        emit Transfer(address(0), owner(), _supply);
        
        // Pre-approve router for efficient swaps
        _approve(address(this), address(router), type(uint256).max);
    }
    
    // ERC20 implementation
    function name() public view override returns (string memory) {
        return _name;
    }
    
    function symbol() public view override returns (string memory) {
        return _symbol;
    }
    
    function decimals() public pure override returns (uint8) {
        return DECIMALS;
    }
    
    function totalSupply() public view override returns (uint256) {
        return _supply;
    }
    
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }
    
    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _performTransfer(_msgSender(), recipient, amount);
        return true;
    }
    
    function allowance(address owner, address spender) public view override returns (uint256) {
        return _approvals[owner][spender];
    }
    
    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }
    
    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        uint256 currentApproval = _approvals[sender][_msgSender()];
        require(currentApproval >= amount, "Transfer amount exceeds allowance");
        
        _performTransfer(sender, recipient, amount);
        _approve(sender, _msgSender(), currentApproval - amount);
        
        return true;
    }
    
    /**
     * @dev Internal approval mechanism
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "Approve from zero address");
        require(spender != address(0), "Approve to zero address");
        
        _approvals[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
    
    /**
     * @dev Core transfer logic with fee processing
     */
    function _performTransfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "Transfer from zero address");
        require(recipient != address(0), "Transfer to zero address");
        require(amount > 0, "Transfer amount must be positive");
        require(_balances[sender] >= amount, "Insufficient balance");
        
        bool shouldApplyFees = _shouldChargeFee(sender, recipient);
        
        // Process fee conversion on sells
        if (shouldApplyFees && _isMarketPair[recipient]) {
            _handleFeeConversion();
        }
        
        uint256 finalAmount = amount;
        
        if (shouldApplyFees) {
            uint256 feeAmount = _computeFeeAmount(sender, recipient, amount);
            if (feeAmount > 0) {
                finalAmount = amount - feeAmount;
                _balances[sender] -= feeAmount;
                _balances[address(this)] += feeAmount;
                emit Transfer(sender, address(this), feeAmount);
            }
        }
        
        // Validate holding limits
        if (limitationsActive && !_limitExempt[recipient]) {
            _validateHoldingLimits(recipient, finalAmount);
        }
        
        _balances[sender] -= finalAmount;
        _balances[recipient] += finalAmount;
        emit Transfer(sender, recipient, finalAmount);
        
        // Monitor for initial liquidity
        if (!liquidityEstablished && recipient == liquidityPair) {
            _monitorLiquidityAddition();
        }
    }
    
    /**
     * @dev Detect when initial liquidity is added
     */
    function _monitorLiquidityAddition() internal {
        if (!liquidityEstablished) {
            uint256 pairBalance = _balances[liquidityPair];
            if (pairBalance > _supply / 5000) { // More than 0.02% of supply
                liquidityEstablished = true;
                emit LiquidityConfirmed(block.timestamp);
            }
        }
    }
    
    /**
     * @dev Validate recipient doesn't exceed holding limits
     */
    function _validateHoldingLimits(address recipient, uint256 amount) internal view {
        if (!_limitExempt[recipient]) {
            require(
                _balances[recipient] + amount <= maximumHolding,
                "Transfer exceeds maximum holding limit"
            );
        }
    }
    
    /**
     * @dev Determine if fees should be applied
     */
    function _shouldChargeFee(address sender, address recipient) internal view returns (bool) {
        return !_feeExempt[sender] && !_feeExempt[recipient] && tradingEnabled;
    }
    
    /**
     * @dev Calculate fee amount
     */
    function _computeFeeAmount(address sender, address recipient, uint256 amount) internal view returns (uint256) {
        uint256 feeRate = 0;
        
        if (_isMarketPair[sender]) {
            // Buy transaction
            feeRate = feeStructure.buyFee;
        } else if (_isMarketPair[recipient]) {
            // Sell transaction
            feeRate = feeStructure.sellFee;
        } else {
            // Transfer transaction
            feeRate = feeStructure.transferFee;
        }
        
        return (amount * feeRate) / FEE_DENOMINATOR;
    }
    
    /**
     * @dev Handle fee conversion
     */
    function _handleFeeConversion() internal {
        uint256 contractBalance = balanceOf(address(this));
        
        if (!inConversion && contractBalance > conversionTrigger) {
            
            // Reset counter on new block
            if (block.number > lastConversionBlock) {
                conversionCounter = 0;
            }
            
            // Limit conversions per block
            if (conversionCounter >= maxConversionsPerBlock) {
                return; 
            }
            
            uint256 tokensToConvert = _calculateConversionAmount(contractBalance);
            
            _convertTokensToETH(tokensToConvert);
            
            uint256 contractETH = address(this).balance;
            if (contractETH > 0) {
                _distributeRevenue(contractETH);
                emit FeeConversionExecuted(tokensToConvert, contractETH);
            }
            
            conversionCounter++;
            lastConversionBlock = block.number;
        }
    }
    
    /**
     * @dev Calculate conversion amount
     */
    function _calculateConversionAmount(uint256 contractBalance) internal view returns (uint256) {
        uint256 conversionAmount = contractBalance;
        
        // Apply maximum conversion limit
        if (conversionAmount > maximumConversion) {
            conversionAmount = maximumConversion;
        }
        
        // Apply safety cap
        if (conversionAmount > conversionCap) {
            conversionAmount = conversionCap;
        }
        
        return conversionAmount;
    }
    
    /**
     * @dev Convert tokens to ETH
     */
    function _convertTokensToETH(uint256 tokenAmount) internal conversionLock {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = nativeToken;
        
        try dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp + 300
        ) {
            // Conversion successful
        } catch {
            // Conversion failed
        }
    }
    
    /**
     * @dev Distribute ETH
     */
    function _distributeRevenue(uint256 ethAmount) internal {
        uint256 primaryAmount = (ethAmount * distribution.primaryShare) / 10000;  
        uint256 secondaryAmount = ethAmount - primaryAmount;
        
        if (primaryAmount > 0) {
            distribution.primaryWallet.sendValue(primaryAmount);
        }
        
        if (secondaryAmount > 0) {
            distribution.secondaryWallet.sendValue(secondaryAmount);
        }
    }
    
    // Administrative functions
    
    /**
     * @dev Activate trading
     */
    function enableTrading() external onlyOwner {
        require(!tradingEnabled, "Trading is already active");
        require(liquidityEstablished, "Liquidity must be established first");
        tradingEnabled = true;
        launchTimestamp = block.timestamp;
        emit TradingActivated(block.timestamp);
    }
    
    /**
     * @dev Activate launch tax
     */
    function activateLaunchTax() external onlyOwner {
        require(!launchTaxActivated, "Launch tax already active");
        require(!feeStructure.locked, "Fee structure is locked");
        
        // Apply launch tax rates
        feeStructure.buyFee = INITIAL_BUY_FEE;
        feeStructure.sellFee = INITIAL_SELL_FEE;
        feeStructure.transferFee = 0;
        
        // Enter reduction phase
        maxFeeReached = false;
        launchTaxActivated = true;
        
        emit LaunchFeesActivated(INITIAL_BUY_FEE, INITIAL_SELL_FEE, block.timestamp);
        emit FeeRatesModified(INITIAL_BUY_FEE, INITIAL_SELL_FEE, 0);
    }
    
    /**
     * @dev Manually mark liquidity as established
     */
    function setLiquidityEstablished() external onlyOwner {
        liquidityEstablished = true;
    }
    
    /**
     * @dev Update fee rates
     */
    function updateFeeRates(
        uint256 newBuyFee,
        uint256 newSellFee,
        uint256 newTransferFee
    ) external onlyOwner {
        require(!feeStructure.locked, "Fee structure is locked");
        require(newTransferFee <= MAXIMUM_FEE, "Transfer fee exceeds maximum");
        
        if (maxFeeReached) {
            // Flexible phase - can adjust freely within limits
            require(newBuyFee <= MAXIMUM_FEE, "Buy fee exceeds maximum");
            require(newSellFee <= MAXIMUM_FEE, "Sell fee exceeds maximum");
        } else {
            // Reduction phase - can only decrease
            require(newBuyFee <= feeStructure.buyFee, "Can only reduce buy fee");
            require(newSellFee <= feeStructure.sellFee, "Can only reduce sell fee");
            
            // Check transition to flexible phase
            if (newBuyFee <= MAXIMUM_FEE && newSellFee <= MAXIMUM_FEE) {
                maxFeeReached = true;
                emit MaximumFeeLimitReached(block.timestamp, "Fee reduction complete - flexible mode activated");
            }
        }
        
        // Apply new rates
        feeStructure.buyFee = newBuyFee;
        feeStructure.sellFee = newSellFee;
        feeStructure.transferFee = newTransferFee;
        
        emit FeeRatesModified(newBuyFee, newSellFee, newTransferFee);
    }
    
    /**
     * @dev Permanently lock fee configuration
     */
    function lockFeeConfiguration() external onlyOwner {
        feeStructure.locked = true;
        emit FeeConfigurationLocked();
    }
    
    /**
     * @dev Update revenue distribution settings
     */
    function updateDistribution(
        address newPrimaryWallet,
        address newSecondaryWallet,
        uint256 newPrimaryShare,
        uint256 newSecondaryShare
    ) external onlyOwner 
      onlyValidAddress(newPrimaryWallet) 
      onlyValidAddress(newSecondaryWallet) {
        require(newPrimaryShare + newSecondaryShare == 10000, "Shares must total 100%");
        
        distribution.primaryWallet = payable(newPrimaryWallet);
        distribution.secondaryWallet = payable(newSecondaryWallet);
        distribution.primaryShare = newPrimaryShare;
        distribution.secondaryShare = newSecondaryShare;
        
        emit DistributionUpdated(
            newPrimaryWallet, 
            newSecondaryWallet, 
            newPrimaryShare, 
            newSecondaryShare
        );
    }
    
    /**
     * @dev Update safety mechanism
     */
    function updateConversionSafeguard(uint256 newConversionCap) external onlyOwner {
        require(newConversionCap >= _supply / 5000, "Minimum 0.02% required");
        require(newConversionCap <= _supply / 20, "Maximum 5% allowed");
        
        conversionCap = newConversionCap;
        emit SafeguardUpdated(newConversionCap);
    }
    
    /**
     * @dev Update MEV protection params
     */
    function updateConversionLimit(uint256 _maxConversions) external onlyOwner {
        require(_maxConversions >= 1 && _maxConversions <= 15, "Invalid conversion limit");
        maxConversionsPerBlock = _maxConversions;
        emit ConversionLimitUpdated(_maxConversions);
    }
    
    /**
     * @dev Update holding limit exemption
     */
    function setLimitExemption(address account, bool exempt) external onlyOwner onlyValidAddress(account) {
        _limitExempt[account] = exempt;
        emit ExemptionStatusChanged(account, exempt);
    }
    
    /**
     * @dev Update maximum holding amount
     */
    function updateMaximumHolding(uint256 newMaximum) external onlyOwner {
        require(newMaximum >= _supply / 500, "Minimum 0.2% required");
        maximumHolding = newMaximum;
        emit HoldingLimitUpdated(newMaximum);
    }
    
    /**
     * @dev Permanently remove all holding limits
     */
    function deactivateLimitations() external onlyOwner {
        require(limitationsActive, "Limitations already inactive");
        limitationsActive = false;
        emit LimitationsDeactivated();
    }
    
    /**
     * @dev Set fee exemption status
     */
    function setFeeExemption(address account, bool exempt) external onlyOwner onlyValidAddress(account) {
        _feeExempt[account] = exempt;
    }
    
    /**
     * @dev Set market pair status
     */
    function setMarketPair(address pair, bool isPair) external onlyOwner onlyValidAddress(pair) {
        _isMarketPair[pair] = isPair;
    }
    
    /**
     * @dev Update conversion params
     */
    function updateConversionSettings(uint256 newTrigger, uint256 newMaximum) external onlyOwner {
        require(newTrigger > 0, "Trigger must be positive");
        require(newMaximum >= newTrigger, "Maximum must exceed trigger");
        
        conversionTrigger = newTrigger;
        maximumConversion = newMaximum;
    }
    
    /**
     * @dev Manual fee conversion
     */
    function manualConversion() external onlyOwner nonReentrant {
        _handleFeeConversion();
    }
    
    /**
     * @dev Emergency ETH recovery
     */
    function recoverETH() external onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to recover");
        
        payable(owner()).sendValue(balance);
    }
    
    /**
     * @dev Emergency token recovery
     */
    function recoverTokens(address tokenAddress, uint256 amount) external onlyOwner nonReentrant {
        require(tokenAddress != address(this), "Cannot recover own tokens");
        
        IERC20(tokenAddress).safeTransfer(owner(), amount);
    }
    
    // View functions
    
    function isFeeExempt(address account) external view returns (bool) {
        return _feeExempt[account];
    }
    
    function isLimitExempt(address account) external view returns (bool) {
        return _limitExempt[account];
    }
    
    function isMarketPair(address pair) external view returns (bool) {
        return _isMarketPair[pair];
    }
    
    function getTaxRates() external view returns (uint256 buyTax, uint256 sellTax, uint256 transferTax) {
        return (feeStructure.buyFee, feeStructure.sellFee, feeStructure.transferFee);
    }

    function hasLiquidityBeenAdded() external view returns (bool) {
        return liquidityEstablished;
    }
    
    /**
     * @dev Return distribution config
     */
    function getDistribution() external view returns (
        address primary, 
        address secondary, 
        uint256 primaryShare, 
        uint256 secondaryShare
    ) {
        return (
            distribution.primaryWallet, 
            distribution.secondaryWallet, 
            distribution.primaryShare, 
            distribution.secondaryShare
        );
    }
    
    function getLimitationStatus() external view returns (bool active, uint256 maximum) {
        return (limitationsActive, maximumHolding);
    }
    
    function getSafeguardStatus() external view returns (uint256 cap, uint256 lastBlock) {
        return (conversionCap, lastConversionBlock);
    }
    
    function getConversionSettings() external view returns (uint256 trigger, uint256 maximum) {
        return (conversionTrigger, maximumConversion);
    }
    
    /**
     * @dev Return fee reduction phase info
     */
    function getFeePhaseStatus() external view returns (bool reachedMaximum, string memory phase) {
        if (maxFeeReached) {
            return (true, "Flexible Phase: Fees adjustable within 0-5% range");
        } else {
            return (false, "Reduction Phase: Fees can only be decreased to 5%");
        }
    }
    
    /**
     * @dev Return launch tax activation info
     */
    function getLaunchTaxStatus() external view returns (bool activated, uint256 launchBuyFee, uint256 launchSellFee) {
        return (launchTaxActivated, INITIAL_BUY_FEE, INITIAL_SELL_FEE);
    }
    
    /**
     * @dev Returns conversion stats for MEV monitoring
     */
    function getConversionStats() external view returns (
        uint256 currentCount,
        uint256 currentBlock,
        uint256 lastBlock,
        bool canConvert
    ) {
        bool canConvertNow = (block.number > lastConversionBlock) || (conversionCounter < maxConversionsPerBlock);
        return (conversionCounter, block.number, lastConversionBlock, canConvertNow);
    }
    
    // Receive ETH
    receive() external payable {}
}

// 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.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC20 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.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

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

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

pragma solidity ^0.8.20;

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

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"tokenName","type":"string"},{"internalType":"string","name":"tokenSymbol","type":"string"},{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"primaryTaxWallet","type":"address"},{"internalType":"address","name":"secondaryTaxWallet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","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":false,"internalType":"uint256","name":"maxConversions","type":"uint256"}],"name":"ConversionLimitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"primaryWallet","type":"address"},{"indexed":false,"internalType":"address","name":"secondaryWallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"primaryShare","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"secondaryShare","type":"uint256"}],"name":"DistributionUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"exempt","type":"bool"}],"name":"ExemptionStatusChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"FeeConfigurationLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensProcessed","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethGenerated","type":"uint256"}],"name":"FeeConversionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"buyFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"transferFee","type":"uint256"}],"name":"FeeRatesModified","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newLimit","type":"uint256"}],"name":"HoldingLimitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"buyFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sellFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"LaunchFeesActivated","type":"event"},{"anonymous":false,"inputs":[],"name":"LimitationsDeactivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"LiquidityConfirmed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"},{"indexed":false,"internalType":"string","name":"message","type":"string"}],"name":"MaximumFeeLimitReached","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"requestedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"actualAmount","type":"uint256"}],"name":"SafeguardTriggered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newConversionCap","type":"uint256"}],"name":"SafeguardUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"TradingActivated","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":"FEE_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INITIAL_BUY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INITIAL_SELL_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VESTING_CONTRACT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activateLaunchTax","outputs":[],"stateMutability":"nonpayable","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":"amount","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":[],"name":"conversionCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"conversionCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"conversionTrigger","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deactivateLimitations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"dexRouter","outputs":[{"internalType":"contract IUniswapV2Router","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distribution","outputs":[{"internalType":"address payable","name":"primaryWallet","type":"address"},{"internalType":"address payable","name":"secondaryWallet","type":"address"},{"internalType":"uint256","name":"primaryShare","type":"uint256"},{"internalType":"uint256","name":"secondaryShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeStructure","outputs":[{"internalType":"uint256","name":"buyFee","type":"uint256"},{"internalType":"uint256","name":"sellFee","type":"uint256"},{"internalType":"uint256","name":"transferFee","type":"uint256"},{"internalType":"bool","name":"locked","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getConversionSettings","outputs":[{"internalType":"uint256","name":"trigger","type":"uint256"},{"internalType":"uint256","name":"maximum","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getConversionStats","outputs":[{"internalType":"uint256","name":"currentCount","type":"uint256"},{"internalType":"uint256","name":"currentBlock","type":"uint256"},{"internalType":"uint256","name":"lastBlock","type":"uint256"},{"internalType":"bool","name":"canConvert","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistribution","outputs":[{"internalType":"address","name":"primary","type":"address"},{"internalType":"address","name":"secondary","type":"address"},{"internalType":"uint256","name":"primaryShare","type":"uint256"},{"internalType":"uint256","name":"secondaryShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFeePhaseStatus","outputs":[{"internalType":"bool","name":"reachedMaximum","type":"bool"},{"internalType":"string","name":"phase","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLaunchTaxStatus","outputs":[{"internalType":"bool","name":"activated","type":"bool"},{"internalType":"uint256","name":"launchBuyFee","type":"uint256"},{"internalType":"uint256","name":"launchSellFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLimitationStatus","outputs":[{"internalType":"bool","name":"active","type":"bool"},{"internalType":"uint256","name":"maximum","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSafeguardStatus","outputs":[{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"uint256","name":"lastBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTaxRates","outputs":[{"internalType":"uint256","name":"buyTax","type":"uint256"},{"internalType":"uint256","name":"sellTax","type":"uint256"},{"internalType":"uint256","name":"transferTax","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasLiquidityBeenAdded","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isLimitExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"isMarketPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastConversionBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchTaxActivated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limitationsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityEstablished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockFeeConfiguration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"manualConversion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxConversionsPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFeeReached","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maximumHolding","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nativeToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recoverETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setFeeExemption","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setLimitExemption","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setLiquidityEstablished","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"isPair","type":"bool"}],"name":"setMarketPair","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":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxConversions","type":"uint256"}],"name":"updateConversionLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newConversionCap","type":"uint256"}],"name":"updateConversionSafeguard","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newTrigger","type":"uint256"},{"internalType":"uint256","name":"newMaximum","type":"uint256"}],"name":"updateConversionSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newPrimaryWallet","type":"address"},{"internalType":"address","name":"newSecondaryWallet","type":"address"},{"internalType":"uint256","name":"newPrimaryShare","type":"uint256"},{"internalType":"uint256","name":"newSecondaryShare","type":"uint256"}],"name":"updateDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newBuyFee","type":"uint256"},{"internalType":"uint256","name":"newSellFee","type":"uint256"},{"internalType":"uint256","name":"newTransferFee","type":"uint256"}],"name":"updateFeeRates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaximum","type":"uint256"}],"name":"updateMaximumHolding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000005f5e1000000000000000000000000007df6bd89e213574c609abb4b587a7fbf2c5077c20000000000000000000000000daa3fc972523d60e83766612bc0c1bdcf7ba65100000000000000000000000000000000000000000000000000000000000000054465706f7400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054445504f54000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : tokenName (string): Depot
Arg [1] : tokenSymbol (string): DEPOT
Arg [2] : initialSupply (uint256): 100000000
Arg [3] : primaryTaxWallet (address): 0x7DF6BD89E213574c609aBb4B587a7fbF2c5077C2
Arg [4] : secondaryTaxWallet (address): 0x0DaA3fC972523d60E83766612bc0C1bDCF7ba651

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000005f5e100
Arg [3] : 0000000000000000000000007df6bd89e213574c609abb4b587a7fbf2c5077c2
Arg [4] : 0000000000000000000000000daa3fc972523d60e83766612bc0c1bdcf7ba651
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 4465706f74000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [8] : 4445504f54000000000000000000000000000000000000000000000000000000