Contract

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628

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

type Currency is address;

interface IHooks {}

struct PoolKey {
    Currency currency0;
    Currency currency1;
    uint24 fee;
    int24 tickSpacing;
    IHooks hooks;
}

interface IERC20Minimal {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
}

interface IPermit2AllowanceTransfer {
    function approve(address token, address spender, uint160 amount, uint48 expiration) external;
}

interface IUniswapV4PositionManager {
    function initializePool(PoolKey calldata key, uint160 sqrtPriceX96) external payable returns (int24);
    function modifyLiquidities(bytes calldata unlockData, uint256 deadline) external payable;
    function nextTokenId() external view returns (uint256);
}

contract BaseLaunchToken {
    struct FeeRecipient {
        address account;
        uint16 bps;
    }

    uint256 public constant TOTAL_SUPPLY = 100_000_000_000 ether;
    uint16 public constant BPS_DENOMINATOR = 10_000;
    uint256 public constant MAX_FEE_RECIPIENTS = 20;

    string public name;
    string public symbol;
    string public imageURI;
    string public metadataURI;

    uint8 public constant decimals = 18;
    uint256 public totalSupply;

    address public owner;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    FeeRecipient[] private _feeRecipients;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event ImageURIUpdated(string imageURI);
    event MetadataURIUpdated(string metadataURI);
    event FeeRecipientsUpdated(address[] accounts, uint16[] bps);
    event ETHDistributed(uint256 amount);
    event ERC20Distributed(address indexed token, uint256 amount);

    error NotOwner();
    error ZeroAddress();
    error InvalidFeeBps();
    error TooManyFeeRecipients();
    error InsufficientBalance();
    error InsufficientAllowance();

    modifier onlyOwner() {
        if (msg.sender != owner) revert NotOwner();
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_,
        string memory imageURI_,
        string memory metadataURI_,
        address initialOwner,
        address supplyReceiver,
        FeeRecipient[] memory feeRecipients_
    ) {
        if (initialOwner == address(0) || supplyReceiver == address(0)) revert ZeroAddress();

        name = name_;
        symbol = symbol_;
        imageURI = imageURI_;
        metadataURI = metadataURI_;
        owner = initialOwner;

        _mint(supplyReceiver, TOTAL_SUPPLY);
        _setFeeRecipients(feeRecipients_);

        emit OwnershipTransferred(address(0), initialOwner);
        emit ImageURIUpdated(imageURI_);
        emit MetadataURIUpdated(metadataURI_);
    }

    receive() external payable {}

    function feeRecipientsLength() external view returns (uint256) {
        return _feeRecipients.length;
    }

    function feeRecipientAt(uint256 index) external view returns (address account, uint16 bps) {
        FeeRecipient memory recipient = _feeRecipients[index];
        return (recipient.account, recipient.bps);
    }

    function feeRecipients() external view returns (FeeRecipient[] memory) {
        return _feeRecipients;
    }

    function setImageURI(string calldata newImageURI) external onlyOwner {
        imageURI = newImageURI;
        emit ImageURIUpdated(newImageURI);
    }

    function setMetadataURI(string calldata newMetadataURI) external onlyOwner {
        metadataURI = newMetadataURI;
        emit MetadataURIUpdated(newMetadataURI);
    }

    function setFeeRecipients(FeeRecipient[] calldata newRecipients) external onlyOwner {
        _setFeeRecipientsCalldata(newRecipients);
    }

    function transferOwnership(address newOwner) external onlyOwner {
        if (newOwner == address(0)) revert ZeroAddress();
        address previousOwner = owner;
        owner = newOwner;
        emit OwnershipTransferred(previousOwner, newOwner);
    }

    function renounceOwnership() external onlyOwner {
        address previousOwner = owner;
        owner = address(0);
        emit OwnershipTransferred(previousOwner, address(0));
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) {
            if (allowed < value) revert InsufficientAllowance();
            unchecked {
                allowance[from][msg.sender] = allowed - value;
            }
            emit Approval(from, msg.sender, allowance[from][msg.sender]);
        }

        _transfer(from, to, value);
        return true;
    }

    function burn(uint256 value) external {
        _burn(msg.sender, value);
    }

    function burnFrom(address account, uint256 value) external {
        uint256 allowed = allowance[account][msg.sender];
        if (allowed != type(uint256).max) {
            if (allowed < value) revert InsufficientAllowance();
            unchecked {
                allowance[account][msg.sender] = allowed - value;
            }
            emit Approval(account, msg.sender, allowance[account][msg.sender]);
        }

        _burn(account, value);
    }

    function distributeETH() external onlyOwner {
        uint256 amount = address(this).balance;
        _distributeETH(amount);
        emit ETHDistributed(amount);
    }

    function distributeERC20(address token) external onlyOwner {
        if (token == address(0)) revert ZeroAddress();
        uint256 amount = IERC20Minimal(token).balanceOf(address(this));
        _distributeERC20(token, amount);
        emit ERC20Distributed(token, amount);
    }

    function _transfer(address from, address to, uint256 value) internal {
        if (to == address(0)) revert ZeroAddress();

        uint256 fromBalance = balanceOf[from];
        if (fromBalance < value) revert InsufficientBalance();

        unchecked {
            balanceOf[from] = fromBalance - value;
            balanceOf[to] += value;
        }

        emit Transfer(from, to, value);
    }

    function _mint(address to, uint256 value) internal {
        if (to == address(0)) revert ZeroAddress();
        totalSupply += value;
        balanceOf[to] += value;
        emit Transfer(address(0), to, value);
    }

    function _burn(address from, uint256 value) internal {
        uint256 fromBalance = balanceOf[from];
        if (fromBalance < value) revert InsufficientBalance();

        unchecked {
            balanceOf[from] = fromBalance - value;
            totalSupply -= value;
        }

        emit Transfer(from, address(0), value);
    }

    function _setFeeRecipients(FeeRecipient[] memory recipients) internal {
        if (recipients.length > MAX_FEE_RECIPIENTS) revert TooManyFeeRecipients();

        delete _feeRecipients;
        uint256 totalBps;
        address[] memory accounts = new address[](recipients.length);
        uint16[] memory bps = new uint16[](recipients.length);

        for (uint256 i; i < recipients.length; ++i) {
            if (recipients[i].account == address(0)) revert ZeroAddress();
            if (recipients[i].bps == 0) revert InvalidFeeBps();
            totalBps += recipients[i].bps;
            _feeRecipients.push(recipients[i]);
            accounts[i] = recipients[i].account;
            bps[i] = recipients[i].bps;
        }

        if (recipients.length != 0 && totalBps != BPS_DENOMINATOR) revert InvalidFeeBps();
        emit FeeRecipientsUpdated(accounts, bps);
    }

    function _setFeeRecipientsCalldata(FeeRecipient[] calldata recipients) internal {
        if (recipients.length > MAX_FEE_RECIPIENTS) revert TooManyFeeRecipients();

        delete _feeRecipients;
        uint256 totalBps;
        address[] memory accounts = new address[](recipients.length);
        uint16[] memory bps = new uint16[](recipients.length);

        for (uint256 i; i < recipients.length; ++i) {
            if (recipients[i].account == address(0)) revert ZeroAddress();
            if (recipients[i].bps == 0) revert InvalidFeeBps();
            totalBps += recipients[i].bps;
            _feeRecipients.push(FeeRecipient({account: recipients[i].account, bps: recipients[i].bps}));
            accounts[i] = recipients[i].account;
            bps[i] = recipients[i].bps;
        }

        if (recipients.length != 0 && totalBps != BPS_DENOMINATOR) revert InvalidFeeBps();
        emit FeeRecipientsUpdated(accounts, bps);
    }

    function _distributeETH(uint256 amount) internal {
        if (_feeRecipients.length == 0 || amount == 0) return;

        uint256 sent;
        for (uint256 i; i < _feeRecipients.length; ++i) {
            uint256 share = i == _feeRecipients.length - 1
                ? amount - sent
                : amount * _feeRecipients[i].bps / BPS_DENOMINATOR;
            sent += share;
            (bool ok,) = _feeRecipients[i].account.call{value: share}("");
            require(ok, "ETH_TRANSFER_FAILED");
        }
    }

    function _distributeERC20(address token, uint256 amount) internal {
        if (_feeRecipients.length == 0 || amount == 0) return;

        uint256 sent;
        for (uint256 i; i < _feeRecipients.length; ++i) {
            uint256 share = i == _feeRecipients.length - 1
                ? amount - sent
                : amount * _feeRecipients[i].bps / BPS_DENOMINATOR;
            sent += share;
            require(IERC20Minimal(token).transfer(_feeRecipients[i].account, share), "ERC20_TRANSFER_FAILED");
        }
    }

}

contract A20ProtocolLauncher {
    uint16 private constant BPS_DENOMINATOR = 10_000;
    uint16 public constant OFFICIAL_FEE_BPS = 100;

    struct LockedV4Position {
        uint256 tokenId;
        Currency currency0;
        Currency currency1;
        bool exists;
    }

    struct LaunchPoolParams {
        PoolKey key;
        uint160 sqrtPriceX96;
        int24 tickLower;
        int24 tickUpper;
        uint128 amount0Max;
        uint128 amount1Max;
        uint256 liquidity;
    }

    struct TokenParams {
        string name;
        string symbol;
        string imageURI;
        string metadataURI;
        address owner;
    }

    address public constant ETHEREUM_V4_POSITION_MANAGER = 0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e;
    address public constant ETHEREUM_PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
    address public constant ETHEREUM_WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    uint24 public constant DEFAULT_LP_FEE = 10_000;
    int24 public constant DEFAULT_TICK_SPACING = 200;
    uint128 public constant DEFAULT_TOKEN_AMOUNT_MAX = 100_000_000_000 ether;

    uint160 public constant INITIAL_SQRT_PRICE_X96_TOKEN_PER_WETH_10_ETH_MARKET_CAP =
        7_974_470_913_604_094_264_140_738_513_890_252;
    uint160 public constant INITIAL_SQRT_PRICE_X96_WETH_PER_TOKEN_10_ETH_MARKET_CAP =
        787_149_618_249_685_149_291_181;
    int24 public constant INITIAL_TICK_TOKEN_PER_WETH_10_ETH_MARKET_CAP = 230_400;
    int24 public constant INITIAL_TICK_WETH_PER_TOKEN_10_ETH_MARKET_CAP = -230_400;

    int24 public constant DEFAULT_TOKEN1_TICK_LOWER = 120_000;
    int24 public constant DEFAULT_TOKEN1_TICK_UPPER = 230_400;
    int24 public constant DEFAULT_TOKEN0_TICK_LOWER = -230_400;
    int24 public constant DEFAULT_TOKEN0_TICK_UPPER = -120_000;

    uint160 private constant DEFAULT_TOKEN1_SQRT_LOWER = 31_953_335_214_378_312_554_014_683_580_590;
    uint160 private constant DEFAULT_TOKEN1_SQRT_UPPER = 7_974_470_913_604_094_264_140_738_513_890_252;
    uint160 private constant DEFAULT_TOKEN0_SQRT_LOWER = 787_149_618_249_685_149_291_181;
    uint160 private constant DEFAULT_TOKEN0_SQRT_UPPER = 196_445_901_289_268_864_651_836_582;
    uint256 private constant Q96 = 2 ** 96;
    uint256 private constant MAX_SALT_ATTEMPTS = 64;
    uint256 public constant MAX_LOCKED_TOKEN_DUST = 100_000;

    bytes1 private constant ACTION_MINT_POSITION = 0x02;
    bytes1 private constant ACTION_SETTLE_PAIR = 0x0d;
    bytes1 private constant ACTION_DECREASE_LIQUIDITY = 0x01;
    bytes1 private constant ACTION_TAKE_PAIR = 0x11;

    IUniswapV4PositionManager public immutable positionManager;
    IPermit2AllowanceTransfer public immutable permit2;
    address public immutable officialFeeRecipient;

    mapping(address => LockedV4Position) public lockedV4Positions;
    uint256 public launchNonce;
    bool private _collectingFees;

    event TokenLaunched(
        address indexed token,
        address indexed owner,
        uint256 indexed v4PositionId,
        PoolKey poolKey,
        int24 tickLower,
        int24 tickUpper,
        uint256 tokenAmountMax,
        uint256 liquidity
    );
    event V4FeesCollectedAndDistributed(
        address indexed token,
        address indexed caller,
        uint256 indexed v4PositionId,
        uint256 amount0,
        uint256 amount1
    );
    event OfficialFeePaid(address indexed token, address indexed recipient, address indexed currency, uint256 amount);
    event TokenSaltSelected(address indexed token, bytes32 indexed salt, uint256 indexed launchNonce);

    error ZeroAddress();
    error ETHNotAccepted();
    error V4PositionNotLocked();
    error NoFeeRecipients();
    error ReentrantCall();
    error NoValidTokenAddress();
    error ExcessTokenDust(uint256 remaining);

    modifier nonReentrant() {
        if (_collectingFees) revert ReentrantCall();
        _collectingFees = true;
        _;
        _collectingFees = false;
    }

    constructor(address officialFeeRecipient_) {
        if (officialFeeRecipient_ == address(0)) revert ZeroAddress();

        positionManager = IUniswapV4PositionManager(ETHEREUM_V4_POSITION_MANAGER);
        permit2 = IPermit2AllowanceTransfer(ETHEREUM_PERMIT2);
        officialFeeRecipient = officialFeeRecipient_;
    }

    receive() external payable {}

    function createTokenAndLaunch(
        TokenParams calldata tokenParams,
        BaseLaunchToken.FeeRecipient[] calldata feeRecipients
    ) external payable returns (BaseLaunchToken token, uint256 v4PositionId) {
        if (msg.value != 0) revert ETHNotAccepted();
        if (tokenParams.owner == address(0)) revert ZeroAddress();

        BaseLaunchToken.FeeRecipient[] memory feeRecipientsMemory =
            new BaseLaunchToken.FeeRecipient[](feeRecipients.length);
        for (uint256 i; i < feeRecipients.length; ++i) {
            feeRecipientsMemory[i] = feeRecipients[i];
        }

        token = _deployLaunchToken(tokenParams, feeRecipientsMemory);

        LaunchPoolParams memory poolParams = _buildLaunchPoolParams(address(token));

        token.approve(address(permit2), type(uint256).max);
        permit2.approve(address(token), address(positionManager), type(uint160).max, type(uint48).max);

        positionManager.initializePool(poolParams.key, poolParams.sqrtPriceX96);
        v4PositionId = positionManager.nextTokenId();

        bytes memory actions = abi.encodePacked(ACTION_MINT_POSITION, ACTION_SETTLE_PAIR);
        bytes[] memory params = new bytes[](2);
        params[0] = abi.encode(
            poolParams.key,
            poolParams.tickLower,
            poolParams.tickUpper,
            poolParams.liquidity,
            poolParams.amount0Max,
            poolParams.amount1Max,
            address(this),
            bytes("")
        );
        params[1] = abi.encode(poolParams.key.currency0, poolParams.key.currency1);

        positionManager.modifyLiquidities(abi.encode(actions, params), block.timestamp);
        lockedV4Positions[address(token)] =
            LockedV4Position({
                tokenId: v4PositionId,
                currency0: poolParams.key.currency0,
                currency1: poolParams.key.currency1,
                exists: true
            });

        uint256 remaining = token.balanceOf(address(this));
        if (remaining > MAX_LOCKED_TOKEN_DUST) revert ExcessTokenDust(remaining);

        emit TokenLaunched(
            address(token),
            tokenParams.owner,
            v4PositionId,
            poolParams.key,
            poolParams.tickLower,
            poolParams.tickUpper,
            DEFAULT_TOKEN_AMOUNT_MAX,
            poolParams.liquidity
        );
    }

    function collectAndDistributeV4Fees(address token, uint256 deadline) external nonReentrant {
        LockedV4Position memory lockedPosition = lockedV4Positions[token];
        if (!lockedPosition.exists) revert V4PositionNotLocked();

        BaseLaunchToken launchToken = BaseLaunchToken(payable(token));
        if (launchToken.feeRecipientsLength() == 0) revert NoFeeRecipients();

        uint256 balance0Before = _currencyBalance(lockedPosition.currency0);
        uint256 balance1Before = _currencyBalance(lockedPosition.currency1);

        bytes memory actions = abi.encodePacked(ACTION_DECREASE_LIQUIDITY, ACTION_TAKE_PAIR);
        bytes[] memory params = new bytes[](2);
        params[0] = abi.encode(lockedPosition.tokenId, uint256(0), uint128(0), uint128(0), bytes(""));
        params[1] = abi.encode(lockedPosition.currency0, lockedPosition.currency1, address(this));

        positionManager.modifyLiquidities(abi.encode(actions, params), deadline);

        uint256 amount0 = _currencyBalance(lockedPosition.currency0) - balance0Before;
        uint256 amount1 = _currencyBalance(lockedPosition.currency1) - balance1Before;

        _distributeLaunchFees(launchToken, lockedPosition.currency0, amount0);
        _distributeLaunchFees(launchToken, lockedPosition.currency1, amount1);

        emit V4FeesCollectedAndDistributed(token, msg.sender, lockedPosition.tokenId, amount0, amount1);
    }

    function _currencyBalance(Currency currency) internal view returns (uint256) {
        address token = Currency.unwrap(currency);
        return token == address(0) ? address(this).balance : IERC20Minimal(token).balanceOf(address(this));
    }

    function _distributeLaunchFees(BaseLaunchToken launchToken, Currency currency, uint256 amount) internal {
        if (amount == 0) return;

        uint256 recipientsLength = launchToken.feeRecipientsLength();
        if (recipientsLength == 0) revert NoFeeRecipients();

        address token = Currency.unwrap(currency);
        uint256 officialFee = amount * OFFICIAL_FEE_BPS / BPS_DENOMINATOR;
        uint256 userFeeAmount = amount - officialFee;

        if (officialFee != 0) {
            _transferCurrency(token, officialFeeRecipient, officialFee);
            emit OfficialFeePaid(address(launchToken), officialFeeRecipient, token, officialFee);
        }

        if (userFeeAmount == 0) return;

        uint256 sent;

        for (uint256 i; i < recipientsLength; ++i) {
            (address account, uint16 bps) = launchToken.feeRecipientAt(i);
            uint256 share = i == recipientsLength - 1 ? userFeeAmount - sent : userFeeAmount * bps / BPS_DENOMINATOR;
            sent += share;

            _transferCurrency(token, account, share);
        }
    }

    function _transferCurrency(address token, address to, uint256 amount) internal {
        if (token == address(0)) {
            (bool ok,) = to.call{value: amount}("");
            require(ok, "ETH_TRANSFER_FAILED");
        } else {
            require(IERC20Minimal(token).transfer(to, amount), "ERC20_TRANSFER_FAILED");
        }
    }

    function _buildLaunchPoolParams(address token) internal pure returns (LaunchPoolParams memory params) {
        if (uint160(token) >= uint160(ETHEREUM_WETH)) revert NoValidTokenAddress();

        params.sqrtPriceX96 = INITIAL_SQRT_PRICE_X96_WETH_PER_TOKEN_10_ETH_MARKET_CAP;
        params.tickLower = DEFAULT_TOKEN0_TICK_LOWER;
        params.tickUpper = DEFAULT_TOKEN0_TICK_UPPER;
        params.amount0Max = DEFAULT_TOKEN_AMOUNT_MAX;
        params.liquidity =
            _liquidityForAmount0(DEFAULT_TOKEN0_SQRT_LOWER, DEFAULT_TOKEN0_SQRT_UPPER, DEFAULT_TOKEN_AMOUNT_MAX);

        params.key = PoolKey({
            currency0: Currency.wrap(token),
            currency1: Currency.wrap(ETHEREUM_WETH),
            fee: DEFAULT_LP_FEE,
            tickSpacing: DEFAULT_TICK_SPACING,
            hooks: IHooks(address(0))
        });
    }

    function _liquidityForAmount0(uint160 sqrtPriceAX96, uint160 sqrtPriceBX96, uint256 amount0)
        internal
        pure
        returns (uint256)
    {
        uint256 intermediate = amount0 * uint256(sqrtPriceAX96) / Q96;
        uint256 liquidity = intermediate * uint256(sqrtPriceBX96) / (uint256(sqrtPriceBX96) - uint256(sqrtPriceAX96));
        return liquidity;
    }

    function _deployLaunchToken(
        TokenParams calldata tokenParams,
        BaseLaunchToken.FeeRecipient[] memory feeRecipients
    ) internal returns (BaseLaunchToken token) {
        bytes32 initCodeHash = keccak256(
            abi.encodePacked(
                type(BaseLaunchToken).creationCode,
                abi.encode(
                    tokenParams.name,
                    tokenParams.symbol,
                    tokenParams.imageURI,
                    tokenParams.metadataURI,
                    tokenParams.owner,
                    address(this),
                    feeRecipients
                )
            )
        );
        uint256 currentLaunchNonce = launchNonce++;
        bytes32 salt = _findTokenSalt(initCodeHash, currentLaunchNonce);

        token = new BaseLaunchToken{salt: salt}(
            tokenParams.name,
            tokenParams.symbol,
            tokenParams.imageURI,
            tokenParams.metadataURI,
            tokenParams.owner,
            address(this),
            feeRecipients
        );
        if (uint160(address(token)) >= uint160(ETHEREUM_WETH)) revert NoValidTokenAddress();

        emit TokenSaltSelected(address(token), salt, currentLaunchNonce);
    }

    function _findTokenSalt(bytes32 initCodeHash, uint256 currentLaunchNonce) internal view returns (bytes32 salt) {
        bytes32 seed = keccak256(abi.encode(block.chainid, msg.sender, currentLaunchNonce, initCodeHash));

        for (uint256 attempt; attempt < MAX_SALT_ATTEMPTS; ++attempt) {
            salt = keccak256(abi.encode(seed, attempt));
            address predicted = address(
                uint160(
                    uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, initCodeHash)))
                )
            );
            if (uint160(predicted) < uint160(ETHEREUM_WETH)) return salt;
        }

        revert NoValidTokenAddress();
    }
}