Token Creation & Deployment

[
  {
    "inputs": [
      {"type": "string", "name": "name"},
      {"type": "string", "name": "symbol"},
      {"type": "uint256", "name": "totalSupply"},
      {"type": "uint256", "name": "tokenAmountForLiquidity"},
      {"type": "address", "name": "feeReceiver"}
    ],
    "name": "createToken",
    "outputs": [
      {"type": "address", "name": "tokenAddress"},
      {"type": "uint256", "name": "tokenId"}
    ],
    "stateMutability": "payable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "factoryCreator",
    "outputs": [{"type": "address"}],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "DEFAULT_FEE",
    "outputs": [{"type": "uint24"}],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "DEFAULT_TICK_SPACING",
    "outputs": [{"type": "int24"}],
    "stateMutability": "view",
    "type": "function"
  }
]

npm install ethers

import { ethers } from 'ethers';
 
const FACTORY_ADDRESS = '0xeF6ce237F69D238Fe3CfAB801f24b4cfd3A54B9D';
 
const FACTORY_ABI = [
  'function createToken(string name, string symbol, uint256 totalSupply, uint256 tokenAmountForLiquidity, address feeReceiver) payable returns (address tokenAddress, uint256 tokenId)',
  'function factoryCreator() view returns (address)',
  'function DEFAULT_FEE() view returns (uint24)',
  'function DEFAULT_TICK_SPACING() view returns (int24)'
];
 
async function createToken(params) {
  const { name, symbol, totalSupply, liquidityTokens, feeReceiver, ethAmount } = params;
  
  // Connect wallet
  if (!window.ethereum) {
    throw new Error('No wallet found. Please install MetaMask.');
  }
  
  const provider = new ethers.BrowserProvider(window.ethereum);
  await provider.send('eth_requestAccounts', []);
  const signer = await provider.getSigner();
  
  // Connect to factory
  const factory = new ethers.Contract(FACTORY_ADDRESS, FACTORY_ABI, signer);
  
  // Convert to wei (18 decimals)
  const totalSupplyWei = ethers.parseEther(totalSupply.toString());
  const liquidityTokensWei = ethers.parseEther(liquidityTokens.toString());
  const ethAmountWei = ethers.parseEther(ethAmount.toString());
  
  try {
    // Call createToken
    const tx = await factory.createToken(
      name,
      symbol,
      totalSupplyWei,
      liquidityTokensWei,
      feeReceiver,
      { value: ethAmountWei }
    );
    
    console.log('Transaction sent:', tx.hash);
    console.log('Waiting for confirmation...');
    
    const receipt = await tx.wait();
    console.log('Token created!', receipt);
    
    // Parse the TokenCreated event from logs
    const event = receipt.logs.find(log => {
      try {
        return factory.interface.parseLog(log)?.name === 'TokenCreated';
      } catch {
        return false;
      }
    });
    
    if (event) {
      const parsed = factory.interface.parseLog(event);
      return {
        success: true,
        txHash: receipt.hash,
        tokenAddress: parsed.args.token,
        lpTokenId: parsed.args.lpTokenId.toString(),
        creator: parsed.args.creator,
        feeReceiver: parsed.args.feeReceiver
      };
    }
    
    return {
      success: true,
      txHash: receipt.hash
    };
  } catch (error) {
    console.error('Error creating token:', error);
    return {
      success: false,
      error: error.message
    };
  }
}
 
// Example usage
const result = await createToken({
  name: 'My Awesome Token',
  symbol: 'MAT',
  totalSupply: 1000000,        // 1 million tokens
  liquidityTokens: 500000,     // 500k tokens to pool (50%)
  feeReceiver: '0x1ab186D064171DB900fa6701A3eF5C5153ecbC24',
  ethAmount: 0.1               // 0.1 ETH to pool
});
 
if (result.success) {
  console.log('Token Address:', result.tokenAddress);
  console.log('LP Token ID:', result.lpTokenId);
  console.log('View on Basescan:', `https://basescan.org/address/${result.tokenAddress}`);
}

import React, { useState } from 'react';
import { ethers } from 'ethers';
 
export default function TokenCreator() {
  const [formData, setFormData] = useState({
    name: '',
    symbol: '',
    totalSupply: '1000000',
    liquidityPercent: 50,
    ethAmount: '0.1',
    feeReceiver: ''
  });
  
  const [isCreating, setIsCreating] = useState(false);
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);
  
  const handleSubmit = async (e) => {
    e.preventDefault();
    setIsCreating(true);
    setError(null);
    setResult(null);
    
    try {
      const liquidityTokens = (formData.totalSupply * formData.liquidityPercent) / 100;
      
      const result = await createToken({
        name: formData.name,
        symbol: formData.symbol,
        totalSupply: formData.totalSupply,
        liquidityTokens: liquidityTokens,
        feeReceiver: formData.feeReceiver,
        ethAmount: formData.ethAmount
      });
      
      if (result.success) {
        setResult(result);
      } else {
        setError(result.error);
      }
    } catch (err) {
      setError(err.message);
    } finally {
      setIsCreating(false);
    }
  };
  
  return (
    <div className="token-creator">
      <h1>Create Your Token</h1>
      
      <form onSubmit={handleSubmit}>
        <div className="form-group">
          <label>Token Name</label>
          <input
            type="text"
            value={formData.name}
            onChange={(e) => setFormData({...formData, name: e.target.value})}
            placeholder="My Awesome Token"
            required
          />
        </div>
        
        <div className="form-group">
          <label>Token Symbol</label>
          <input
            type="text"
            value={formData.symbol}
            onChange={(e) => setFormData({...formData, symbol: e.target.value.toUpperCase()})}
            placeholder="MAT"
            maxLength={10}
            required
          />
        </div>
        
        <div className="form-group">
          <label>Total Supply</label>
          <input
            type="number"
            value={formData.totalSupply}
            onChange={(e) => setFormData({...formData, totalSupply: e.target.value})}
            placeholder="1000000"
            min="1"
            required
          />
          <small>Total number of tokens to create</small>
        </div>
        
        <div className="form-group">
          <label>Liquidity % (Tokens to Pool)</label>
          <input
            type="range"
            value={formData.liquidityPercent}
            onChange={(e) => setFormData({...formData, liquidityPercent: e.target.value})}
            min="10"
            max="100"
            step="5"
          />
          <span>{formData.liquidityPercent}%</span>
          <small>
            Pool: {(formData.totalSupply * formData.liquidityPercent / 100).toLocaleString()} tokens
            <br/>
            You get: {(formData.totalSupply * (100 - formData.liquidityPercent) / 100).toLocaleString()} tokens
          </small>
        </div>
        
        <div className="form-group">
          <label>ETH Amount for Liquidity</label>
          <input
            type="number"
            value={formData.ethAmount}
            onChange={(e) => setFormData({...formData, ethAmount: e.target.value})}
            placeholder="0.1"
            min="0"
            step="0.01"
          />
          <small>ETH to pair with tokens in the pool (can be 0)</small>
        </div>
        
        <div className="form-group">
          <label>Fee Receiver Address</label>
          <input
            type="text"
            value={formData.feeReceiver}
            onChange={(e) => setFormData({...formData, feeReceiver: e.target.value})}
            placeholder="0x..."
            required
          />
          <small>Address that receives token fees from sells</small>
        </div>
        
        <div className="summary">
          <h3>Summary</h3>
          <p>Pool Fee: 1.00% (Uniswap V4)</p>
          <p>Token fees (sells) → Your fee receiver</p>
          <p>ETH fees (buys) → Factory creator</p>
          <p>Estimated Gas: ~$5-10 (Base mainnet)</p>
        </div>
        
        <button type="submit" disabled={isCreating}>
          {isCreating ? 'Creating Token...' : 'Create Token'}
        </button>
      </form>
      
      {error && (
        <div className="error">
          <h3>Error</h3>
          <p>{error}</p>
        </div>
      )}
      
      {result && (
        <div className="success">
          <h3>Token Created Successfully! 🎉</h3>
          <p><strong>Token Address:</strong> {result.tokenAddress}</p>
          <p><strong>LP Token ID:</strong> {result.lpTokenId}</p>
          <p><strong>Transaction:</strong> <a href={\`https://basescan.org/tx/\${result.txHash}\`} target="_blank">View on Basescan</a></p>
          <p><strong>Token Contract:</strong> <a href={\`https://basescan.org/address/\${result.tokenAddress}\`} target="_blank">View Token</a></p>
        </div>
      )}
    </div>
  );
}

function validateInputs(formData) {
  const errors = [];
  
  // Validate name
  if (!formData.name || formData.name.length < 1 || formData.name.length > 50) {
    errors.push('Token name must be 1-50 characters');
  }
  
  // Validate symbol
  if (!formData.symbol || formData.symbol.length < 1 || formData.symbol.length > 10) {
    errors.push('Token symbol must be 1-10 characters');
  }
  
  // Validate total supply
  const supply = parseFloat(formData.totalSupply);
  if (isNaN(supply) || supply <= 0) {
    errors.push('Total supply must be greater than 0');
  }
  
  // Validate liquidity percentage
  const liquidityTokens = (supply * formData.liquidityPercent) / 100;
  if (liquidityTokens <= 0 || liquidityTokens > supply) {
    errors.push('Invalid liquidity amount');
  }
  
  // Validate fee receiver
  if (!ethers.isAddress(formData.feeReceiver)) {
    errors.push('Invalid fee receiver address');
  }
  
  // Validate ETH amount
  const ethAmount = parseFloat(formData.ethAmount);
  if (isNaN(ethAmount) || ethAmount < 0) {
    errors.push('Invalid ETH amount');
  }
  
  return errors;
}

{
  name: "Test Token",
  symbol: "TEST",
  totalSupply: 1000000,        // 1M tokens
  liquidityTokens: 500000,     // 500K tokens (50%)
  ethAmount: 0.01,             // 0.01 ETH
  feeReceiver: "0x..." // Your test wallet
}

npm install ethers

# wagmi + RainbowKit (React)
npm install wagmi @rainbow-me/rainbowkit
 
# web3modal (Multi-framework)
npm install @web3modal/wagmi
 
# ConnectKit (React)
npm install connectkit