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

interface ITickerTool {
    function deployToken(
        string calldata _name,
        string calldata _symbol,
        uint256 _supply,
        bytes32 _salt
    ) external payable returns (address token, uint256 tokenId);

    function generateSalt(
        address deployer,
        string calldata name,
        string calldata symbol,
        uint256 supply
    ) external view returns (bytes32 salt, address token);
}

interface IERC20 {
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function balanceOf(address account) external view returns (uint256);
}

contract Deployer {
    ITickerTool public tickertool;
    address public owner;

    event TokenDeployed(
        address indexed token,
        uint256 tokenId,
        address indexed deployer
    );

    constructor(address _tickertool) {
        owner = msg.sender;
        tickertool = ITickerTool(_tickertool);
    }

    function deploy(
        string calldata _name,
        string calldata _symbol,
        uint256 _supply
    ) external payable {

        // Generate the salt using the Tickertool contract
        (bytes32 salt, ) = tickertool.generateSalt(
            address(this),
            _name,
            _symbol,
            _supply
        );

        // Deploy the token using the Tickertool contract
        (address token, uint256 tokenId) = tickertool.deployToken{
            value: msg.value
        }(_name, _symbol, _supply, salt);

        // Transfer tokens to the deployer
        uint256 balance = IERC20(token).balanceOf(address(this));
        if (balance > 0) {
            bool success = IERC20(token).transfer(msg.sender, balance);
            require(success, "Token transfer failed");
        }

        // Emit the event to log the deployment
        emit TokenDeployed(token, tokenId, msg.sender);
    }

    function withdraw() external {
        require(msg.sender == owner, "Only deployer can withdraw");
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETHER to withdraw");
        (bool success, ) = owner.call{value: balance}("");
        require(success, "ETHER transfer failed");
    }

    function withdrawERC20(address _token) public {
        require(msg.sender == owner, "Only deployer can withdraw");
        IERC20 erc20 = IERC20(_token);
        erc20.transfer(owner, erc20.balanceOf(address(this)));
    }

    /// @notice Function to receive Ether. msg.data must be empty
    receive() external payable {}

    /// @notice Fallback function is called when msg.data is not empty
    fallback() external payable {}
}

{
  "compilationTarget": {
    "contracts/Deployer.sol": "Deployer"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}