Smart Contract Development for Memecoins: Complete Technical Guide

┌─────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT LIFECYCLE                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   1. WRITE     ──▶   2. COMPILE    ──▶   3. DEPLOY         │
│   (Code)             (Bytecode)          (Blockchain)       │
│                                                              │
│                          │                                   │
│                          ▼                                   │
│                                                              │
│   4. VERIFY    ──▶   5. INTERACT   ──▶   6. UPGRADE        │
│   (Source)           (Users/DApps)       (if upgradeable)   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MemecoinToken is ERC20, Ownable {
    uint8 private constant _decimals = 18;
    uint256 private constant TOTAL_SUPPLY = 1_000_000_000 * 10**18; // 1 billion tokens
    
    constructor(
        string memory name,
        string memory symbol,
        address initialOwner
    ) ERC20(name, symbol) Ownable(initialOwner) {
        _mint(initialOwner, TOTAL_SUPPLY);
    }
    
    function decimals() public pure override returns (uint8) {
        return _decimals;
    }
    
    // Burn function for deflationary mechanics
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
    }
}

contract TaxToken is ERC20, Ownable {
    uint256 public buyTax = 5; // 5%
    uint256 public sellTax = 5; // 5%
    address public taxWallet;
    
    function _update(
        address from,
        address to,
        uint256 amount
    ) internal override {
        uint256 taxAmount = 0;
        
        if (from != owner() && to != owner()) {
            if (to == uniswapV2Pair) {
                // Selling
                taxAmount = (amount * sellTax) / 100;
            } else if (from == uniswapV2Pair) {
                // Buying
                taxAmount = (amount * buyTax) / 100;
            }
        }
        
        if (taxAmount > 0) {
            super._update(from, taxWallet, taxAmount);
            amount -= taxAmount;
        }
        
        super._update(from, to, amount);
    }
}

# Create a new token
spl-token create-token

# Output: Creating token <TOKEN_ADDRESS>
# Output: Signature: <TRANSACTION_SIGNATURE>

# Create token account
spl-token create-account <TOKEN_ADDRESS>

# Mint tokens
spl-token mint <TOKEN_ADDRESS> 1000000000

# Disable future minting (fixed supply)
spl-token authorize <TOKEN_ADDRESS> mint --disable

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};

declare_id!("YourProgramId");

#[program]
pub mod memecoin {
    use super::*;

    pub fn initialize(ctx: Context<Initialize>, total_supply: u64) -> Result<()> {
        let mint = &ctx.accounts.mint;
        let authority = &ctx.accounts.authority;
        
        // Initialize token with supply
        token::mint_to(
            CpiContext::new(
                ctx.accounts.token_program.to_account_info(),
                token::MintTo {
                    mint: mint.to_account_info(),
                    to: ctx.accounts.token_account.to_account_info(),
                    authority: authority.to_account_info(),
                },
            ),
            total_supply,
        )?;
        
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = authority, mint::decimals = 9, mint::authority = authority)]
    pub mint: Account<'info, token::Mint>,
    
    #[account(init, payer = authority, token::mint = mint, token::authority = authority)]
    pub token_account: Account<'info, TokenAccount>,
    
    #[account(mut)]
    pub authority: Signer<'info>,
    
    pub token_program: Program<'info, Token>,
    pub system_program: Program<'info, System>,
    pub rent: Sysvar<'info, Rent>,
}

# Install Node.js (if not installed)
# Then install development tools
npm install -g hardhat
npm install -g foundry

# Create project
npx hardhat init

# Install OpenZeppelin (recommended security-audited contracts)
npm install @openzeppelin/contracts

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Install Solana CLI
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

# Install Anchor (Solana development framework)
cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
avm install latest

// test/MemecoinToken.test.js
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MemecoinToken", function () {
  let token, owner, addr1, addr2;

  beforeEach(async function () {
    [owner, addr1, addr2] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("MemecoinToken");
    token = await Token.deploy("Test Meme", "MEME", owner.address);
  });

  describe("Deployment", function () {
    it("Should set the right name and symbol", async function () {
      expect(await token.name()).to.equal("Test Meme");
      expect(await token.symbol()).to.equal("MEME");
    });

    it("Should assign the total supply to the owner", async function () {
      const ownerBalance = await token.balanceOf(owner.address);
      expect(await token.totalSupply()).to.equal(ownerBalance);
    });
  });

  describe("Transactions", function () {
    it("Should transfer tokens between accounts", async function () {
      await token.transfer(addr1.address, 50);
      expect(await token.balanceOf(addr1.address)).to.equal(50);
    });

    it("Should fail if sender doesn't have enough tokens", async function () {
      await expect(
        token.connect(addr1).transfer(owner.address, 1)
      ).to.be.reverted;
    });
  });
});

npx hardhat test

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();
  
  console.log("Deploying contracts with account:", deployer.address);
  
  const Token = await ethers.getContractFactory("MemecoinToken");
  const token = await Token.deploy(
    "My Memecoin",
    "MEME",
    deployer.address
  );
  
  await token.waitForDeployment();
  console.log("Token deployed to:", await token.getAddress());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

# For testnet
npx hardhat run scripts/deploy.js --network sepolia

# For mainnet
npx hardhat run scripts/deploy.js --network mainnet

# Using Hardhat
npx hardhat verify --network mainnet <CONTRACT_ADDRESS> "My Memecoin" "MEME" "<OWNER_ADDRESS>"

# Using Etherscan
# Go to your contract on Etherscan > Code > Verify and Publish

1. Go to app.uniswap.org
2. Connect wallet with token supply
3. Select your token and ETH (or other paired token)
4. Add liquidity with desired amounts
5. Confirm transaction and receive LP tokens

1. Go to raydium.io
2. Navigate to Create Pool
3. Select your token and SOL
4. Set initial price and liquidity amounts
5. Confirm and create pool

// Good - using audited contracts
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

// Avoid - writing from scratch
// contract MyToken { ... } // More prone to errors

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract SecureToken is ERC20, Ownable, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    
    constructor() ERC20("Secure Meme", "SMEME") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }
    
    function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
}

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SecureWithdraw is ReentrancyGuard {
    function withdraw() public nonReentrant {
        // Withdrawal logic
    }
}

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract TokenHandler {
    using SafeERC20 for IERC20;
    
    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        token.safeTransfer(to, amount);
    }
}

import "@openzeppelin/contracts/security/Pausable.sol";

contract PausableToken is ERC20, Pausable, Ownable {
    function pause() public onlyOwner {
        _pause();
    }
    
    function unpause() public onlyOwner {
        _unpause();
    }
    
    function _update(
        address from,
        address to,
        uint256 amount
    ) internal override whenNotPaused {
        super._update(from, to, amount);
    }
}