filterswap-contracts/FilterDeployer.sol at main · BytePhoenixCoding/filterswap-contracts · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
//SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8;

interface IFilterManager {
    function treasuryAddress() external view returns (address);
    function distributorAddress() external view returns (address);
    function routerAddress() external view returns (address);
    function deployerMintFee() external view returns (uint);
    function deployerMaxOwnerShare() external view returns (uint);
    function tokenTemplateAddresses(uint) external view returns (address);
    function isTokenVerified(address) external view returns (bool);
    function verifyToken(address) external;
}

interface IERC20 {
    function balanceOf(address) external view returns (uint);
    function transfer(address, uint) external returns (bool);
    function transferFrom(address, address, uint) external returns (bool);
    function approve(address, uint) external returns (bool);
}

interface IFilterRouter {
    function addLiquidity(address, address, uint, uint, uint, uint, address, uint, uint) external returns (uint, uint, uint);
    function addLiquidityETH(address, uint, uint, uint, address, uint, uint) external payable returns (uint, uint, uint);
}

interface IDeployedToken {
    function initializeToken(string memory, string memory, address, address, bytes32[] memory) external;
}

library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        require(IERC20(token).approve(to, value), "FilterDeployer: APPROVE_FAILED");
    }

    function safeTransfer(address token, address to, uint value) internal {
        require(IERC20(token).transfer(to, value), "FilterDeployer: TRANSFER_FAILED");
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        require(IERC20(token).transferFrom(from, to, value), "FilterDeployer: TRANSFER_FROM_FAILED");
    }
}

contract FilterDeployer {
    address public managerAddress;
    IFilterManager filterManager;

    constructor(address _managerAddress) {
        managerAddress = _managerAddress;
        filterManager = IFilterManager(managerAddress);
    }

    function cloneContract(address _addressToClone) private returns (address) {
        address deployedAddress;

        assembly {
            mstore(0x0, or (0x5880730000000000000000000000000000000000000000803b80938091923cF3, mul(_addressToClone, 0x1000000000000000000)))
            deployedAddress := create(0, 0, 32)
        }

        return deployedAddress;
    }

    function createToken(uint _tokenType, string memory _tokenName, string memory _tokenSymbol, bytes32[] memory _tokenArgs, address _baseTokenAddress, uint _baseTokenAmount, uint _ownerShare, uint _liquidityLockTime) external returns (address deployedTokenAddress) {
        require(_ownerShare <= filterManager.deployerMaxOwnerShare(), "FilterDeployer: OWNER_SHARE_TOO_HIGH");
        require(filterManager.tokenTemplateAddresses(_tokenType) != address(0), "FilterDeployer: INVALID_TOKEN_TYPE");
        require(IERC20(_baseTokenAddress).balanceOf(msg.sender) >= _baseTokenAmount, "FilterDeployer: INSUFFICIENT_BASE_TOKEN_AMOUNT");
        require(filterManager.isTokenVerified(_baseTokenAddress), "FilterDeployer: BASE_TOKEN_NOT_VERIFIED");

        TransferHelper.safeTransferFrom(_baseTokenAddress, msg.sender, address(this), _baseTokenAmount);
        TransferHelper.safeTransfer(_baseTokenAddress, filterManager.treasuryAddress(), (filterManager.deployerMintFee() * IERC20(_baseTokenAddress).balanceOf(address(this))) / 10000);

        deployedTokenAddress = cloneContract(filterManager.tokenTemplateAddresses(_tokenType));

        IDeployedToken(deployedTokenAddress).initializeToken(_tokenName, _tokenSymbol, msg.sender, address(this), _tokenArgs);
        TransferHelper.safeTransfer(deployedTokenAddress, msg.sender, (IERC20(deployedTokenAddress).balanceOf(address(this)) * _ownerShare) / 10000);
        filterManager.verifyToken(deployedTokenAddress);

        TransferHelper.safeApprove(_baseTokenAddress, filterManager.routerAddress(), type(uint).max);
        TransferHelper.safeApprove(deployedTokenAddress, filterManager.routerAddress(), type(uint).max);

        IFilterRouter(filterManager.routerAddress()).addLiquidity(
            _baseTokenAddress,
            deployedTokenAddress,
            IERC20(_baseTokenAddress).balanceOf(address(this)),
            IERC20(deployedTokenAddress).balanceOf(address(this)),
            0,
            0,
            msg.sender,
            block.timestamp,
            _liquidityLockTime
        );
    }

    function createTokenETH(uint _tokenType, string memory _tokenName, string memory _tokenSymbol, bytes32[] memory _tokenArgs, uint _ownerShare, uint _liquidityLockTime) external payable returns (address deployedTokenAddress) {
        require(_ownerShare <= filterManager.deployerMaxOwnerShare(), "FilterDeployer: OWNER_SHARE_TOO_HIGH");
        require(filterManager.tokenTemplateAddresses(_tokenType) != address(0), "FilterDeployer: INVALID_TOKEN_TYPE");
        require(msg.value > 0, "FilterDeployer: NO_ETH_SUPPLIED");

        payable(filterManager.treasuryAddress()).transfer((filterManager.deployerMintFee() * address(this).balance) / 10000);

        deployedTokenAddress = cloneContract(filterManager.tokenTemplateAddresses(_tokenType));
        IDeployedToken(deployedTokenAddress).initializeToken(_tokenName, _tokenSymbol, msg.sender, address(this), _tokenArgs);

        TransferHelper.safeTransfer(deployedTokenAddress, msg.sender, (IERC20(deployedTokenAddress).balanceOf(address(this)) * _ownerShare) / 10000);
        filterManager.verifyToken(deployedTokenAddress);
        TransferHelper.safeApprove(deployedTokenAddress, filterManager.routerAddress(), type(uint).max);

        IFilterRouter(filterManager.routerAddress()).addLiquidityETH{value: address(this).balance}(
            deployedTokenAddress,
            IERC20(deployedTokenAddress).balanceOf(address(this)),
            0,
            0,
            msg.sender,
            block.timestamp,
            _liquidityLockTime
        );
    }

    function createPresaleToken(uint _tokenType, string memory _tokenName, string memory _tokenSymbol, bytes32[] memory _tokenArgs, address _ownerAddress) external returns (address deployedTokenAddress) {
        require(msg.sender == filterManager.distributorAddress());

        deployedTokenAddress = cloneContract(filterManager.tokenTemplateAddresses(_tokenType));
        IDeployedToken(deployedTokenAddress).initializeToken(_tokenName, _tokenSymbol, _ownerAddress, msg.sender, _tokenArgs);
    }
}