// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
// ================================================================
//  LitVMTokenFactory | Fee: 0.05 zkLTC per token deploy
//  LitVM LiteForge  |  Chain 4441  |  https://api.republicstats.xyz/litvm/rpc
// ================================================================
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract FactoryToken is ERC20, Ownable {
    uint8 private _d;
    bool public mintable;
    bool public burnable;
    bool public pausable;
    bool private _paused;

    constructor(string memory n, string memory s, uint8 d, uint256 supply, bool m, bool b, bool p, address creator) ERC20(n, s) Ownable(creator) {
        _d = d;
        mintable = m;
        burnable = b;
        pausable = p;
        _mint(creator, supply);
    }

    function decimals() public view override returns (uint8) { return _d; }
    function mint(address to, uint256 amt) external onlyOwner { require(mintable, "Disabled"); _mint(to, amt); }
    function burn(uint256 amt) external { require(burnable, "Disabled"); _burn(msg.sender, amt); }
    function pause() external onlyOwner { require(pausable, "Disabled"); _paused = true; }
    function unpause() external onlyOwner { require(pausable, "Disabled"); _paused = false; }
    function _update(address from, address to, uint256 v) internal override { require(!_paused, "Paused"); super._update(from, to, v); }
}

contract LitVMTokenFactory is Ownable {
    uint256 public fee = 0.05 ether;
    address[] public all;
    mapping(address => address[]) public byCreator;
    event Deployed(address indexed token, address indexed creator, string name, string symbol);

    constructor() Ownable(msg.sender) {}

    function deploy(string calldata name, string calldata symbol, uint8 decimals, uint256 supply, bool mintable, bool burnable, bool pausable) external payable returns (address) {
        require(msg.value >= fee, "Fee low");
        require(bytes(name).length > 0 && bytes(symbol).length > 0, "Name required");
        require(supply > 0, "Supply > 0");
        (bool ok,) = owner().call{value: msg.value}("");
        require(ok, "Fee transfer fail");
        FactoryToken t = new FactoryToken(name, symbol, decimals, supply, mintable, burnable, pausable, msg.sender);
        address a = address(t);
        all.push(a);
        byCreator[msg.sender].push(a);
        emit Deployed(a, msg.sender, name, symbol);
        return a;
    }

    function setFee(uint256 f_) external onlyOwner { fee = f_; }
    function getAll() external view returns (address[] memory) { return all; }
    function getByCreator(address c) external view returns (address[] memory) { return byCreator[c]; }
    function withdraw() external onlyOwner {
        (bool ok,) = owner().call{value: address(this).balance}("");
        require(ok, "Withdraw fail");
    }
    receive() external payable {}
}