Skip to main content
UwUwUwUwUwUwUwU

​
Create Token in 1 Click

We have a Token Factory ready for you at Degen Hub. Create Token This is a free ERC20 Token that’s straight 🔥 and follows our community’s vibe:
  1. 🚫💰 Not Mintable: We ain’t about that unlimited supply life. Your token’s got a fixed supply from day one, so you know it’s legit. 💪
  2. 🍯🚫 Not a Honey Pot: We don’t mess with that sticky situation. Your token’s clean and ready to trade without any sketchy tricks. 😌
  3. 🚫💸 No Tax: Ain’t nobody got time for that extra fee nonsense. Your token’s tax-free, so you can keep more of your hard-earned gains. 🤑
So, what you waiting for? Grab your free ERC20 Token and let’s get this party started! 🎉💸 DegenHub’s got your back, and we’re ready to help you make some serious moves in the DeFi world. 😏 Verified Contracts

​
Customize Token

now that your token’s out there in the wild, it’s time to make it stand out from the crowd! 🌟 You gotta customize that bad boy to get the community hyped up and ready to jump on board. Here’s your quick-hit guide:
  1. 🎨 Slap on a dope logo that’ll make your token stand out like a neon sign in a dark alley.
  2. 📝 Cook up a spicy description that tells people why your token’s the next big thing. Keep it short, sweet, and hype! 🔥
  3. 🐦 Get your tweet on and start spreading the word. Build that hype on Twitter and get the #DeFi community talking. 🗣️
  4. 📱 Drop a Telegram group and get your community vibing. Keep ‘em updated and engaged, and watch your squad grow! 💬
Customize token

​
NERD ALERT!

Deployment Addresses
Full ERC20 contract for the big nerd!
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

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

contract ERC20Default is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint8 decimals,
        uint256 initialSupply
    ) ERC20(name, symbol, decimals) {
        _mint(msg.sender, initialSupply);
    }
}

abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 amount
    );

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(
        address spender,
        uint256 amount
    ) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        unchecked {
            if (to == address(0)) {
                // Cannot underflow because a user's balance
                // will never be larger than the total supply.
                totalSupply -= amount;
            } else {
                // Cannot overflow because the sum of all user
                // balances can't exceed the max uint256 value.
                balanceOf[to] += amount;
            }
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max)
            allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            if (to == address(0)) {
                totalSupply -= amount;
            } else {
                balanceOf[to] += amount;
            }
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    // Burn = transfer to address(0).
}