📊Token Distribution

$ATHENA tokens will be distributed through a fair launch on Uniswap.

Overview

• Symbol: $ATHENA

• Max Supply: 1,000,000,000

• Total Supply: 1,000,000,000

• Token Liquidity On Launch- 5 ETH and 1,000,000,000 (100%) $ATHENA

Fair Launch Mechanisms

Due to the initial liquidity being 5 ETH, there is a risk of whales accumulating a majority of the supply and overall price volatility. In order to mitigate these risks, the token launch will be accompanied by the following:

• maxTokensPerWallet- A method that will limit the maximum number of tokens a wallet can hold, set to 20,000,000 $ATHENA (2%). This limit will be removed automatically by the isLimitEnforced and liquidityThreshold variables

• maxWalletLimitEnabled- A boolean that determines whether maxTokensPerWallet is enforced

• WALLET_LIMIT_THRESHOLD- A defined liquidity threshold in the contract that must be met before maxWalletLimitEnabled is set to false, effectively disabling maxTokensPerWallet

• On top of the default 3% tax, where 1% is allocated to LP/farms, an additional 2% tax will be implemented at launch to increase liquidity until LIQUIDITY_TAX_THRESHOLD is met, at which point it will then be automatically disabled

• totalEthAddedToLiquidity

Code snippet below, outlining the liquidity adding function in the contract that updates the totalEthAddedToLiquidity, which will disable maxWalletLimitEnabled and liquidity tax when met:

function addLiquidityManually(uint256 tokenAmount) external {
        require(isUniswapV2RouterSet, "Uniswap V2 Router not set");
        require(tokenAmount > 0, "Must provide tokens for liquidity");
        require(balanceOf(msg.sender) >= tokenAmount, "Insufficient balance");

        uint256 half = tokenAmount / 2;
        
        // Get the expected ETH amount
        uint256 expectedEth = getExpectedEthForTokens(half);
        
        // Set acceptable slippage (e.g., 5%)
        uint256 minEthAmount = expectedEth * 95 / 100;

        uint256 initialTokenBalance = balanceOf(address(this));
        uint256 initialEthBalance = address(this).balance;

        _transfer(msg.sender, address(this), tokenAmount);

        uint256 ethForLiquidity = _swapTokensForEth(half, minEthAmount);

        (uint256 tokenUsed, uint256 ethUsed, uint256 liquidity) = _addLiquidity(
            tokenAmount - half,
            ethForLiquidity
        );

        totalEthAddedToLiquidity += uint128(ethUsed);

        if (totalEthAddedToLiquidity >= WALLET_LIMIT_THRESHOLD && maxWalletLimitEnabled) {
            maxWalletLimitEnabled = false;
        }

        if (totalEthAddedToLiquidity >= LIQUIDITY_TAX_THRESHOLD && taxInfo.liquidityTax > 0) {
            taxInfo.liquidityTax = 0;
        }

        // Return leftover tokens
        uint256 leftoverTokens = balanceOf(address(this)) - initialTokenBalance;
        if (leftoverTokens > 0) {
            _transfer(address(this), msg.sender, leftoverTokens);
        }

        // Return leftover ETH
        uint256 leftoverEth = address(this).balance - initialEthBalance;
        if (leftoverEth > 0) {
            (bool success, ) = msg.sender.call{value: leftoverEth}("");
            require(success, "ETH transfer failed");
        }

        emit LiquidityAdded(half, ethUsed, tokenUsed, liquidity);
    }