LeeJinSol

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

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

contract TokenFactory is Ownable {
    uint256 public constant CREATE_FEE = 0.01 ether;
    address public presaleContract;

    event TokenCreated(address tokenAddress, string name, string symbol);

    constructor(address _presaleContract) Ownable(msg.sender) {
        require(_presaleContract != address(0), "Presale contract address cannot be zero");
        presaleContract = _presaleContract;
    }

    function createToken(string memory name, string memory symbol) external payable {
        require(msg.value == CREATE_FEE, "Must send 0.01 BNB to create token");
        require(bytes(name).length > 0, "Token name cannot be empty");
        require(bytes(symbol).length > 0, "Token symbol cannot be empty");

        CustomToken newToken = new CustomToken(name, symbol, 100_000_000 * 10**18);
        require(newToken.transfer(presaleContract, 100_000_000 * 10**18), "Token transfer failed");

        emit TokenCreated(address(newToken), name, symbol);
    }

    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

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

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

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

contract Presale is Ownable {
    IERC20 public token;
    uint256 public constant INITIAL_RATE = 10_000_000;
    uint256 public constant TARGET_BNB = 5 ether;

    uint256 public totalBNB;
    mapping(address => uint256) public contributions;
    mapping(address => uint256) public tokenBalances;

    constructor(IERC20 _token) Ownable(msg.sender) {
        token = _token;
    }

    function buyTokens() external payable {
        uint256 tokenAmount = msg.value * INITIAL_RATE;
        require(token.balanceOf(address(this)) >= tokenAmount, "Not enough tokens");

        contributions[msg.sender] += msg.value;
        tokenBalances[msg.sender] += tokenAmount;
        totalBNB += msg.value;
    }
}

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);

  const CustomToken = await hre.ethers.getContractFactory("CustomToken");
  const testToken = await CustomToken.deploy("Test Token", "TST", ethers.parseEther("100000000"));
  await testToken.waitForDeployment();
  console.log("Test Token deployed to:", await testToken.getAddress());

  const Presale = await hre.ethers.getContractFactory("Presale");
  const presale = await Presale.deploy(await testToken.getAddress());
  await presale.waitForDeployment();
  console.log("Presale deployed to:", await presale.getAddress());

  const TokenFactory = await hre.ethers.getContractFactory("TokenFactory");
  const tokenFactory = await TokenFactory.deploy(await presale.getAddress());
  await tokenFactory.waitForDeployment();
  console.log("TokenFactory deployed to:", await tokenFactory.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/deploy.js --network bscTestnet

import React, { useState } from "react";
import { ethers } from "ethers";
import TokenFactoryABI from "../abis/TokenFactory.json";

const TOKEN_FACTORY_ADDRESS = "0xd9d2231675C43a4751AE5d262Ee54bc565C50d4f";

const CreateTokenModal = ({ onClose, onCreate, signer }) => {
  const [name, setName] = useState("");
  const [symbol, setSymbol] = useState("");
  const [error, setError] = useState("");

  const handleSubmit = async () => {
    if (!signer) {
      setError("Please connect your wallet first.");
      return;
    }

    try {
      const tokenFactory = new ethers.Contract(
        TOKEN_FACTORY_ADDRESS,
        TokenFactoryABI,
        signer
      );
      const tx = await tokenFactory.createToken(name, symbol, {
        value: ethers.parseEther("0.01"),
        gasLimit: 1000000,
      });
      await tx.wait();
      onCreate({ name, symbol });
      onClose();
    } catch (err) {
      setError("Transaction failed: " + err.message);
    }
  };

  return (
    <div className="fixed inset-0 bg-black bg-opacity-70 flex items-center justify-center">
      <div className="bg-gray-800 p-6 rounded-lg w-full max-w-md shadow-xl">
        <h2 className="text-xl font-semibold mb-4">Create New Token</h2>
        {error && <div className="mb-4 p-2 bg-red-600 text-white rounded">{error}</div>}
        <div className="mb-4">
          <label className="block mb-1 text-gray-300">Token Name</label>
          <input
            type="text"
            value={name}
            onChange={(e) => setName(e.target.value)}
            className="w-full p-2 bg-gray-700 rounded border border-gray-600"
            placeholder="My Token"
          />
        </div>
        <div className="mb-4">
          <label className="block mb-1 text-gray-300">Token Symbol</label>
          <input
            type="text"
            value={symbol}
            onChange={(e) => setSymbol(e.target.value)}
            className="w-full p-2 bg-gray-700 rounded border border-gray-600"
            placeholder="MTK"
          />
        </div>
        <div className="flex justify-end space-x-3">
          <button onClick={onClose} className="bg-gray-600 px-4 py-2 rounded-lg">
            Cancel
          </button>
          <button onClick={handleSubmit} className="bg-blue-600 px-4 py-2 rounded-lg">
            Create (0.01 BNB)
          </button>
        </div>
      </div>
    </div>
  );
};

export default CreateTokenModal;

cd frontend
npm start