ERC20Factory

{{
  "language": "Solidity",
  "sources": {
    "LaunchStream/contracts/contracts/ERC20Factory.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "./ERC20Token.sol";

/**
 * @title LaunchStream ERC20 Token Factory
 * @dev Factory contract for creating ERC20 tokens on LaunchStream platform
 */
contract ERC20Factory {
    address public treasury;
    uint256 public creationFee = 0.01 ether; // Fee for creating tokens
    
    mapping(address => bool) public createdTokens;
    mapping(address => address[]) public tokensByCreator;
    address[] public allTokens;
    
    event TokenCreated(
        address indexed tokenAddress,
        address indexed creator,
        string name,
        string symbol,
        uint256 totalSupply,
        uint8 decimals
    );
    
    event FeeUpdated(uint256 newFee);
    event TreasuryUpdated(address newTreasury);
    
    modifier onlyTreasury() {
        require(msg.sender == treasury, "Only treasury can call this");
        _;
    }
    
    constructor(address _treasury) {
        treasury = _treasury;
    }
    
    /**
     * @dev Creates a new ERC20 token
     * @param _name Token name
     * @param _symbol Token symbol
     * @param _totalSupply Total supply (without decimals)
     * @param _decimals Number of decimals
     * @param _owner Token owner address
     * @return Token contract address
     */
    function createToken(
        string memory _name,
        string memory _symbol,
        uint256 _totalSupply,
        uint8 _decimals,
        address _owner
    ) external payable returns (address) {
        require(msg.value >= creationFee, "Insufficient fee");
        require(_totalSupply > 0, "Total supply must be greater than 0");
        require(_owner != address(0), "Invalid owner address");
        require(bytes(_name).length > 0, "Name cannot be empty");
        require(bytes(_symbol).length > 0, "Symbol cannot be empty");
        
        // Create new token contract
        ERC20Token newToken = new ERC20Token(
            _name,
            _symbol,
            _totalSupply,
            _decimals,
            _owner
        );
        
        address tokenAddress = address(newToken);
        
        // Update mappings
        createdTokens[tokenAddress] = true;
        tokensByCreator[_owner].push(tokenAddress);
        allTokens.push(tokenAddress);
        
        // Transfer fee to treasury
        if (msg.value > 0) {
            payable(treasury).transfer(msg.value);
        }
        
        emit TokenCreated(
            tokenAddress,
            _owner,
            _name,
            _symbol,
            _totalSupply,
            _decimals
        );
        
        return tokenAddress;
    }
    
    /**
     * @dev Get tokens created by a specific address
     * @param _creator Creator address
     * @return Array of token addresses
     */
    function getTokensByCreator(address _creator) external view returns (address[] memory) {
        return tokensByCreator[_creator];
    }
    
    /**
     * @dev Get total number of tokens created
     */
    function getTotalTokens() external view returns (uint256) {
        return allTokens.length;
    }
    
    /**
     * @dev Update creation fee (only treasury)
     * @param _newFee New fee amount
     */
    function updateCreationFee(uint256 _newFee) external onlyTreasury {
        creationFee = _newFee;
        emit FeeUpdated(_newFee);
    }
    
    /**
     * @dev Update treasury address (only current treasury)
     * @param _newTreasury New treasury address
     */
    function updateTreasury(address _newTreasury) external onlyTreasury {
        require(_newTreasury != address(0), "Invalid treasury address");
        treasury = _newTreasury;
        emit TreasuryUpdated(_newTreasury);
    }
}"
    },
    "LaunchStream/contracts/contracts/ERC20Token.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * @title LaunchStream ERC20 Token
 * @dev Standard ERC20 token implementation for LaunchStream platform
 */
contract ERC20Token {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    address public owner;
    
    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowances;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }
    
    constructor(
        string memory _name,
        string memory _symbol,
        uint256 _totalSupply,
        uint8 _decimals,
        address _owner
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        totalSupply = _totalSupply * 10**_decimals;
        owner = _owner;
        balances[_owner] = totalSupply;
        emit Transfer(address(0), _owner, totalSupply);
    }
    
    function balanceOf(address account) public view returns (uint256) {
        return balances[account];
    }
    
    function transfer(address to, uint256 amount) public returns (bool) {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }
    
    function allowance(address tokenOwner, address spender) public view returns (uint256) {
        return allowances[tokenOwner][spender];
    }
    
    function approve(address spender, uint256 amount) public returns (bool) {
        allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    
    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
        require(balances[from] >= amount, "Insufficient balance");
        require(allowances[from][msg.sender] >= amount, "Insufficient allowance");
        
        balances[from] -= amount;
        balances[to] += amount;
        allowances[from][msg.sender] -= amount;
        
        emit Transfer(from, to, amount);
        return true;
    }
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}