Contract

SE(SE)0x60e28F63bA1B75346D0e7bf9a76dA91807751A09

Overview

ETH Balance

0 ETH

ETH Value

$0.00 (@ $1,898/ETH)

Token Holdings

—

More Info

Private Name Tags

—

Token Tracker

SE (SE)→ token page

Contract Creator

0x16cf…0dd7 at txn 0x9fc1ae…8cdbd7

Additional Info

Funded By

—

Token Approvals

Review token approvals →

AnalyticsHolders

HIDE LOW VALUE

Latest 0 from a total of 0 transactions

	Transaction Hash	Method ?	Block	Age	From		To	Amount	Txn Fee ?
No direct transactions — this address is only ever reached via internal calls (common for a contract only invoked through a router or proxy). View Internal Transactions →

First‹Page 1 of 1›Last

Show:Records

Loading…

1 value-transferring internal transactions

Block	Age	Parent Transaction Hash	Type	Method	From		To	Value
9,122,184	35 days agoTue, 14 Jul 2026 01:08:06 UTC	0x9fc1ae…8cdbd7	CREATE2	deployCoin	0x16cf…0dd7	IN	0x60e2…1a09	0 ETH

First‹Page 1 of 1›Last

Show:Records

Loading…

Latest 0 from a total of 0 token transfers

	Transaction Hash	Method	Block	Age	From		To	Amount	Token
no token transfers for this address yet

First‹Page 1 of 1›Last

Show:Records

Loading…

	Transaction Hash	Method	Block	Age	From		To	Type	Item
no NFT transfers for this address yet

Type	Age	Block	Details
no cross-chain L1↔L2 transactions for this address

✓ VerifiedExact MatchSE⤢ Open full

Contract Name

Token (SE)

Compiler

solidity · v0.8.35+commit.47b9dedd

Optimization

Yes · 200 runs

EVM Version

cancun

Source

Mirrored from Robinhood Chain explorer

Contract Source Code

Outline

I IStateView

ƒ getSlot0

I IToken

ƒ creator

ƒ withdrawFees

I IWETH

ƒ withdraw

C Factory

ƒ setKlikHook

ƒ setLaunchPeriod

ƒ deployCoin

ƒ getTokenBytecode

ƒ getPenalty

ƒ toggleDeployCoin

ƒ createLiquidityConfig

ƒ updateLiquidityConfig

ƒ deleteLiquidityConfig

ƒ getLiquidityConfig

ƒ setItemsPerPage

ƒ getAllTokensByCreator

ƒ getDeploysByPage

ƒ withdrawFeesWETH

ƒ withdrawFeesETH

ƒ provideLiquidityV4

ƒ _calculateLiquidity

ƒ _buyToken

ƒ collectFees

ƒ changeTokenFeeReceiver

ƒ getTokenPrice

ƒ getMarketCap

ƒ getTokenFeesGenerated

C Token

ƒ _update

ƒ isLaunchPeriodActive

ƒ owner

ƒ withdrawFees

ƒ changeCreator

Token.sol

pragma solidity ^0.8.20;
/*

 __  _  _      ____  __  _      _____  ____  ____    ____  ____     __    ___
|  |/ ]| |    |    ||  |/ ]    |     ||    ||    \  /    ||    \   /  ]  /  _]
|  ' / | |     |  | |  ' /     |   __| |  | |  _  ||  o  ||  _  | /  /  /  [_
|    \ | |___  |  | |    \     |  |_   |  | |  |  ||     ||  |  |/  /  |    _]
|     \|     | |  | |     \ __ |   _]  |  | |  |  ||  _  ||  |  /   \_ |   [_
|  .  ||     | |  | |  .  ||  ||  |    |  | |  |  ||  |  ||  |  \     ||     |
|__|\_||_____||____||__|\_||__||__|   |____||__|__||__|__||__|__|\____||_____|
V4 Edition

https://klik.finance
https://x.com/klik_evm

*/

pragma solidity >=0.8.9;

import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IPositionManager} from "v4-periphery/src/interfaces/IPositionManager.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {Actions} from "v4-periphery/src/libraries/Actions.sol";
import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";

interface IStateView {
    function getSlot0(PoolId poolId) external view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee);
}

import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";
import {LPFeeLibrary} from "@uniswap/v4-core/src/libraries/LPFeeLibrary.sol";
import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
import {IV4Router} from "@uniswap/v4-periphery/src/interfaces/IV4Router.sol";
import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
import {Commands} from "@uniswap/universal-router/contracts/libraries/Commands.sol";

import "v4-core/test/utils/LiquidityAmounts.sol";

interface IToken {
    function creator() external view returns (address);
    function withdrawFees() external returns (uint256);
}

interface IWETH {
    function withdraw(uint256 amount) external;
}

contract Factory is ReentrancyGuard {
    event ERC20TokenCreated(address tokenAddress);

    struct TokenInfo {
        address tokenAddress;
        string name;
        string symbol;
        address deployer;
        uint256 time;
        string metadata;
        uint256 marketCapInETH;
        uint256 totalFeesGenerated;
    }

    mapping(uint256 => TokenInfo) public deployedTokens;
    mapping(address => TokenInfo) public tokenInfoByAddress;
    uint256 public tokenCount = 0;
    address public platformController;
    address public klikHook; // Universal hook for all tokens (can be updated)
    uint256 private itemsPerPage = 250; // Configurable items per page for pagination
    
    // Mapping to store token addresses by creator/deployer
    mapping(address => address[]) public creatorTokens;
    
    // Mapping to track total fees generated per token
    mapping(address => uint256) public tokenFeesGenerated;

    // Mapping to store the hook address used at deploy time per token
    mapping(address => address) public tokenHook;

    // Uniswap v4 deployment addresses — Robinhood Chain (chain ID 4663)
    IAllowanceTransfer constant PERMIT2 = IAllowanceTransfer(address(0x000000000022D473030F116dDEE9F6B43aC78BA3));
    address public constant POSITION_MANAGER = 0x58daec3116aae6D93017bAAea7749052E8a04fA7;
    IPositionManager positionManager = IPositionManager(POSITION_MANAGER);
    address public constant POOL_MANAGER = 0x8366a39CC670B4001A1121B8F6A443A643e40951;
    IPoolManager poolManager = IPoolManager(POOL_MANAGER);
    address public constant STATE_VIEW = 0xF3334192D15450CdD385c8B70e03f9A6bD9E673b;
    IStateView stateView = IStateView(STATE_VIEW);
    uint256 constant Q96 = 2 ** 96;
    address public constant WETH = 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73; // Canonical WETH on Robinhood Chain
    address public constant UNIVERSAL_ROUTER = 0x8876789976dEcBfCbBbe364623C63652db8C0904;
    IUniversalRouter router = IUniversalRouter(UNIVERSAL_ROUTER);

    uint24 private constant FEE_TIER = 0;

    bool public deployCoinEnabled = true;
    
    // Liquidity configuration struct
    struct LiquidityConfig {
        uint160 sqrtPriceX96;       // sqrtPriceX96 for the pool (address(0) is always currency0)
        int24 tickLower;            // Lower tick for the position
        int24 tickUpper;            // Upper tick for the position
        uint256 amount0Desired;     // Desired amount of currency0 (ETH)
        uint256 amount1Desired;     // Desired amount of currency1 (Token)
        uint256 virtualAmount;      // Virtual ETH amount for market cap calculation
        uint256 penaltyMultiplier;  // Penalty multiplier (50 = 50%, 100 = 100%, 200 = 200%)
    }
    
    // Multiple liquidity configurations
    mapping(uint256 => LiquidityConfig) public liquidityConfigs;
    uint256 public liquidityConfigCount = 0;
    uint256 public launchPeriod = 300; // blocks; set to 0 to disable max-wallet restrictions

    event TokenPurchased(address buyer, address tokenOut, uint256 ethSpent, uint256 tokensReceived);
    event KlikHookUpdated(address oldHook, address newHook);

    constructor(address _klikHook) {
        platformController = msg.sender;
        klikHook = _klikHook;

        // Pre-seeded liquidity configurations (IDs 0-4). All single-sided:
        // full 1B token supply, no ETH. virtualAmount = starting market cap
        // in ETH; sqrtPriceX96 prices the full supply at exactly that amount.
        // penaltyMultiplier 0 = no deploy-buy tax (100 = standard penalty).

        // ID 0: 0.69 ETH virtual liquidity (default)
        liquidityConfigs[0] = LiquidityConfig({
            sqrtPriceX96: 3014831488601586337191090825970934,
            tickLower: -887200,
            tickUpper: 210800,
            amount0Desired: 0,
            amount1Desired: 1000000000000000000000000000,
            virtualAmount: 690000000000000000,
            penaltyMultiplier: 0
        });

        // ID 1: 1 ETH virtual liquidity
        liquidityConfigs[1] = LiquidityConfig({
            sqrtPriceX96: 2505411999795360582221170761428213,
            tickLower: -887200,
            tickUpper: 207200,
            amount0Desired: 0,
            amount1Desired: 1000000000000000000000000000,
            virtualAmount: 1000000000000000000,
            penaltyMultiplier: 0
        });

        // ID 2: 2 ETH virtual liquidity
        liquidityConfigs[2] = LiquidityConfig({
            sqrtPriceX96: 1771577727172025373304338615273325,
            tickLower: -887200,
            tickUpper: 200200,
            amount0Desired: 0,
            amount1Desired: 1000000000000000000000000000,
            virtualAmount: 2000000000000000000,
            penaltyMultiplier: 0
        });

        // ID 3: 5 ETH virtual liquidity
        liquidityConfigs[3] = LiquidityConfig({
            sqrtPriceX96: 1120408587790087695236213992013890,
            tickLower: -887200,
            tickUpper: 191000,
            amount0Desired: 0,
            amount1Desired: 1000000000000000000000000000,
            virtualAmount: 5000000000000000000,
            penaltyMultiplier: 0
        });

        // ID 4: 10 ETH virtual liquidity
        liquidityConfigs[4] = LiquidityConfig({
            sqrtPriceX96: 792280926924313289846529216293289,
            tickLower: -887200,
            tickUpper: 184200,
            amount0Desired: 0,
            amount1Desired: 1000000000000000000000000000,
            virtualAmount: 10000000000000000000,
            penaltyMultiplier: 0
        });

        liquidityConfigCount = 5;
    }

    function setKlikHook(address _newHook) external {
        require(msg.sender == platformController, "Caller is not controller");
        address oldHook = klikHook;
        klikHook = _newHook;
        emit KlikHookUpdated(oldHook, _newHook);
    }

    function setLaunchPeriod(uint256 _blocks) external {
        require(msg.sender == platformController, "Caller is not controller");
        launchPeriod = _blocks;
    }

    receive() external payable {}

    function deployCoin(string memory _name, string memory _symbol, string memory _metadata, bytes32 salt, uint256 configId) public payable returns (uint256 tokensReceived) {
        require(deployCoinEnabled, "Token deployment is currently disabled");
        require(configId < liquidityConfigCount, "Invalid liquidity config ID");
        
        Token t = new Token{salt: salt}(
            _name,
            _symbol,
            msg.sender,
            address(this),
            launchPeriod
        );

        address coin_address = address(t);

        emit ERC20TokenCreated(coin_address);

        provideLiquidityV4(coin_address, configId);

        tokensReceived = 0; // Initialize return value

        if (msg.value > 0) {
            LiquidityConfig memory config = liquidityConfigs[configId];
            uint256 basePenalty = getPenalty(msg.value); // in basis points (e.g., 2500 = 25%)
            uint256 taxBps = (basePenalty * config.penaltyMultiplier) / 100; // Apply config multiplier
            uint256 tax;
            uint256 amountAfterTax;

            // Assembly optimized math operations
            unchecked {
                assembly {
                    tax := div(mul(callvalue(), taxBps), 10000)
                    amountAfterTax := sub(callvalue(), tax)
                }
            }

            uint256 tokensBefore = IERC20(coin_address).balanceOf(address(this));
            _buyToken(coin_address, amountAfterTax);
            uint256 tokensAfter = IERC20(coin_address).balanceOf(address(this));
            tokensReceived = tokensAfter - tokensBefore;
            
            // Transfer tokens to buyer
            IERC20(coin_address).transfer(msg.sender, tokensReceived);
            
            emit TokenPurchased(msg.sender, coin_address, amountAfterTax, tokensReceived);
        }

        // Cache tokenCount to avoid multiple SLOAD operations
        uint256 currentTokenCount = tokenCount;

        TokenInfo memory newTokenInfo = TokenInfo({
            tokenAddress: coin_address,
            name: _name,
            symbol: _symbol,
            deployer: msg.sender,
            time: block.timestamp,
            metadata: _metadata,
            marketCapInETH: 0,
            totalFeesGenerated: 0
        });

        deployedTokens[currentTokenCount] = newTokenInfo;
        tokenInfoByAddress[coin_address] = newTokenInfo;
        tokenHook[coin_address] = klikHook;

        // Add token to creator's array
        creatorTokens[msg.sender].push(coin_address);

        // Assembly optimized increment (unchecked)
        assembly {
            sstore(tokenCount.slot, add(currentTokenCount, 1))
        }

        return tokensReceived;
    }

    // Returns the exact init_code that deployCoin will use, so frontends can
    // compute the CREATE2 address for a given salt before submitting the tx.
    // launchPeriod is read from current state — callers must re-read this if
    // the controller changes launchPeriod between salt-mining and deploy, or
    // the predicted address will diverge from the actual one.
    function getTokenBytecode(
        string memory _name,
        string memory _symbol,
        address creator
    ) public view returns (bytes memory bytecode) {
        bytecode = abi.encodePacked(
            type(Token).creationCode,
            abi.encode(_name, _symbol, creator, address(this), launchPeriod)
        );
    }

    function getPenalty(uint256 ethAmount) public pure returns (uint256) {
        if (ethAmount < 0.05 ether) return 0;
        if (ethAmount >= 0.30 ether) return 5000; // max 50%

        uint256 slope = 18000;
        uint256 delta = ethAmount - 0.05 ether;
        uint256 penalty = 500 + (delta * slope) / 1 ether;

        return penalty;
    }

    function toggleDeployCoin() external {
        require(msg.sender == platformController, "Caller is not controller");
        deployCoinEnabled = !deployCoinEnabled;
    }

    // Create new liquidity configuration
    function createLiquidityConfig(
        uint160 _sqrtPriceX96,
        int24 _tickLower,
        int24 _tickUpper,
        uint256 _amount0Desired,
        uint256 _amount1Desired,
        uint256 _virtualAmount,
        uint256 _penaltyMultiplier
    ) external returns (uint256 configId) {
        require(msg.sender == platformController, "Only platform controller can create liquidity config");
        require(_penaltyMultiplier <= 500, "Penalty multiplier must be at most 500%");

        configId = liquidityConfigCount;
        liquidityConfigs[configId] = LiquidityConfig({
            sqrtPriceX96: _sqrtPriceX96,
            tickLower: _tickLower,
            tickUpper: _tickUpper,
            amount0Desired: _amount0Desired,
            amount1Desired: _amount1Desired,
            virtualAmount: _virtualAmount,
            penaltyMultiplier: _penaltyMultiplier
        });
        liquidityConfigCount++;

        return configId;
    }
    
    // Update existing liquidity configuration
    function updateLiquidityConfig(
        uint256 _configId,
        uint160 _sqrtPriceX96,
        int24 _tickLower,
        int24 _tickUpper,
        uint256 _amount0Desired,
        uint256 _amount1Desired,
        uint256 _virtualAmount,
        uint256 _penaltyMultiplier
    ) external {
        require(msg.sender == platformController, "Only platform controller can update liquidity config");
        require(_configId < liquidityConfigCount, "Invalid config ID");
        require(_penaltyMultiplier <= 500, "Penalty multiplier must be at most 500%");

        liquidityConfigs[_configId] = LiquidityConfig({
            sqrtPriceX96: _sqrtPriceX96,
            tickLower: _tickLower,
            tickUpper: _tickUpper,
            amount0Desired: _amount0Desired,
            amount1Desired: _amount1Desired,
            virtualAmount: _virtualAmount,
            penaltyMultiplier: _penaltyMultiplier
        });
    }
    
    // Delete liquidity configuration (sets to zero values)
    function deleteLiquidityConfig(uint256 _configId) external {
        require(msg.sender == platformController, "Only platform controller can delete liquidity config");
        require(_configId < liquidityConfigCount, "Invalid config ID");
        require(_configId != 0, "Cannot delete default config");
        
        delete liquidityConfigs[_configId];
    }
    
    // Get liquidity configuration
    function getLiquidityConfig(uint256 _configId) external view returns (LiquidityConfig memory) {
        require(_configId < liquidityConfigCount, "Invalid config ID");
        return liquidityConfigs[_configId];
    }

    // Change the number of items per page for pagination
    function setItemsPerPage(uint256 _itemsPerPage) external {
        require(msg.sender == platformController, "Only platform controller can change items per page");
        require(_itemsPerPage > 0 && _itemsPerPage <= 1000, "Items per page must be between 1 and 1000");
        itemsPerPage = _itemsPerPage;
    }
    
    // Get all tokens for a creator in one call  
    function getAllTokensByCreator(address _creator) public view returns (address[] memory) {
        return creatorTokens[_creator];
    }

    function getDeploysByPage(uint256 page, uint256 order) public view returns (TokenInfo[] memory) {
        require(tokenCount > 0, "No tokens deployed");

        uint256 totalPages = (tokenCount + itemsPerPage - 1) / itemsPerPage;
        require(page < totalPages, "Page out of range");

        uint256 start;
        uint256 end;
        uint256 j = 0;

        if (order == 0) {
            // Newest first
            start = tokenCount > (page + 1) * itemsPerPage ? tokenCount - (page + 1) * itemsPerPage : 0;
            end = tokenCount - page * itemsPerPage;
            if (end > tokenCount) end = tokenCount;
        } else {
            // Oldest first
            start = page * itemsPerPage;
            end = start + itemsPerPage;
            if (end > tokenCount) end = tokenCount;
        }

        TokenInfo[] memory tokens = new TokenInfo[](end - start);

        for (uint256 i = start; i < end; i++) {
            uint256 index = order == 0 ? end - 1 - (i - start) : i;
            TokenInfo memory info = deployedTokens[index];

            // Calculate market cap using the correct formula
            uint256 marketCap = getMarketCap(info.tokenAddress);

            tokens[j++] = TokenInfo({
                tokenAddress: info.tokenAddress,
                name: info.name,
                symbol: info.symbol,
                deployer: info.deployer,
                time: info.time,
                metadata: info.metadata,
                marketCapInETH: marketCap,
                totalFeesGenerated: tokenFeesGenerated[info.tokenAddress]
            });
        }

        return tokens;
    }

    function withdrawFeesWETH() external {
        require(msg.sender == platformController, "Caller is not controller");
        uint256 wethBalance = IERC20(WETH).balanceOf(address(this));
        require(wethBalance > 0, "No WETH to withdraw");

        IWETH(WETH).withdraw(wethBalance);

        (bool success, ) = msg.sender.call{value: wethBalance}("");
        require(success, "ETH transfer failed");
    }

    function withdrawFeesETH() external {
        require(msg.sender == platformController, "Caller is not controller");

        uint256 ethBalance = address(this).balance;
        require(ethBalance > 0, "No ETH to withdraw");

        (bool success, ) = msg.sender.call{value: ethBalance}("");
        require(success, "ETH transfer failed");
    }

    function provideLiquidityV4(address tokenA, uint256 configId) internal {
        LiquidityConfig memory config = liquidityConfigs[configId];
        
        // Since address(0) is always < any token address, it's always currency0
        // No need for complex comparison logic
        IERC20 token = IERC20(tokenA);

        token.approve(address(PERMIT2), type(uint256).max);
        PERMIT2.approve(tokenA, address(POSITION_MANAGER), type(uint160).max, type(uint48).max);
        PERMIT2.approve(tokenA, address(POOL_MANAGER), type(uint160).max, type(uint48).max);

        PoolKey memory pool = PoolKey({
            currency0: Currency.wrap(address(0)),  // ETH is always currency0
            currency1: Currency.wrap(address(tokenA)), // Token is always currency1
            fee: 0,
            tickSpacing: 200,
            hooks: IHooks(klikHook) // Use universal hook
        });

        poolManager.initialize(pool, config.sqrtPriceX96);

        uint128 liquidity = _calculateLiquidity(
            config.sqrtPriceX96,
            config.tickLower,
            config.tickUpper,
            config.amount0Desired,
            config.amount1Desired
        );

        bytes memory actions = abi.encodePacked(uint8(Actions.MINT_POSITION), uint8(Actions.SETTLE_PAIR));

        bytes memory hookData = new bytes(0);

        bytes[] memory params = new bytes[](2);
        params[0] = abi.encode(
            pool,
            config.tickLower,
            config.tickUpper,
            liquidity,
            config.amount0Desired,
            config.amount1Desired,
            address(0x000000000000000000000000000000000000dEaD), // LP burned — no removal functions exist in this factory anyway; burning makes the lock verifiable on-chain
            hookData
        );

        params[1] = abi.encode(pool.currency0, pool.currency1);

        try positionManager.modifyLiquidities(
            abi.encode(actions, params),
            block.timestamp + 120
        ) {
            // Successfully added liquidity
        } catch (bytes memory reason) {
            assembly {
                revert(add(reason, 0x20), mload(reason))
            }
        }
    }

    function _calculateLiquidity(
        uint160 sqrtPriceX96,
        int24 tickLower,
        int24 tickUpper,
        uint256 amount0Desired,
        uint256 amount1Desired
    ) private pure returns (uint128) {
        return LiquidityAmounts.getLiquidityForAmounts(
            sqrtPriceX96,
            TickMath.getSqrtPriceAtTick(tickLower),
            TickMath.getSqrtPriceAtTick(tickUpper),
            amount0Desired,
            amount1Desired
        );
    }

    // Mirror of IV4Router.ExactInputSingleParams, declared locally so its
    // poolKey field uses THIS file's PoolKey type. Referencing IV4Router's
    // struct directly fails to compile: its PoolKey comes from a different
    // import path (@uniswap/v4-core) than the factory's (v4-core), and Solidity
    // treats the two as distinct types. The ABI layout is identical, which is
    // all the Universal Router's CalldataDecoder reads.
    struct ExactInputSingleParams {
        PoolKey poolKey;
        bool zeroForOne;
        uint128 amountIn;
        uint128 amountOutMinimum;
        bytes hookData;
    }

    function _buyToken(address tokenAddress, uint256 ethAmount) internal {
        // Create PoolKey for ETH -> Token swap
        PoolKey memory pool = PoolKey({
            currency0: Currency.wrap(address(0)), // ETH
            currency1: Currency.wrap(tokenAddress), // New token
            fee: 0,
            tickSpacing: 200,
            hooks: IHooks(klikHook) // Use universal hook
        });

        // Encode the Universal Router command
        bytes memory commands = abi.encodePacked(uint8(Commands.V4_SWAP));
        bytes[] memory inputs = new bytes[](1);

        // Encode V4Router actions
        bytes memory actions = abi.encodePacked(
            uint8(Actions.SWAP_EXACT_IN_SINGLE),
            uint8(Actions.SETTLE_ALL),
            uint8(Actions.TAKE_ALL)
        );

        // Prepare parameters for each action.
        // params[0] MUST be the ExactInputSingleParams struct (not its fields
        // spread out) — the struct encoding carries a leading offset word that
        // the Universal Router's CalldataDecoder requires. Spreading the fields
        // omits that word and reverts SliceOutOfBounds() on current UR builds.
        bytes[] memory params = new bytes[](3);
        params[0] = abi.encode(
            ExactInputSingleParams({
                poolKey: pool,
                zeroForOne: true, // ETH (currency0) -> Token (currency1)
                amountIn: uint128(ethAmount),
                amountOutMinimum: uint128(0), // 0 = no minimum requirement
                hookData: bytes("")
            })
        );
        params[1] = abi.encode(pool.currency0, ethAmount); // SETTLE_ALL params
        params[2] = abi.encode(pool.currency1, uint128(0)); // TAKE_ALL params

        // Combine actions and params into inputs
        inputs[0] = abi.encode(actions, params);

        // Execute the swap
        uint256 deadline = block.timestamp + 120;
        router.execute{value: ethAmount}(commands, inputs, deadline);

        // Tokens remain in contract - caller handles transfer and event emission
    }

    function collectFees(address tokenAddress) external nonReentrant returns (uint256 ethCollected) {
        address creator = IToken(tokenAddress).creator();
        require(msg.sender == creator || msg.sender == platformController, "Not authorized");

        uint256 balanceBefore = address(this).balance;
        IToken(tokenAddress).withdrawFees();
        uint256 balanceAfter = address(this).balance;
        
        ethCollected = balanceAfter - balanceBefore;

        if (ethCollected > 0) {
            tokenFeesGenerated[tokenAddress] += ethCollected;

            // Platform share is taken atomically by the hook at swap time.
            // Everything in the token contract is the creator's portion.
            (bool success, ) = payable(creator).call{value: ethCollected}("");
            require(success, "ETH transfer to creator failed");
        }

        return ethCollected;
    }

    function changeTokenFeeReceiver(address tokenAddress, address newCreator) external {
        address currentCreator = IToken(tokenAddress).creator();
        require(msg.sender == platformController || msg.sender == currentCreator, "Not authorized");
        require(newCreator != address(0), "New creator cannot be zero address");

        Token(payable(tokenAddress)).changeCreator(newCreator);
    }

    function getTokenPrice(address tokenAddress) public view returns (bytes32 poolIdBytes, uint160 sqrtPrice, uint256 calculatedPrice, uint256 marketCapETH) {
        // Create PoolKey for ETH/Token pool
        address hook = tokenHook[tokenAddress] != address(0) ? tokenHook[tokenAddress] : klikHook;
        PoolKey memory poolKey = PoolKey({
            currency0: Currency.wrap(address(0)), // ETH
            currency1: Currency.wrap(tokenAddress), // Token
            fee: 0,
            tickSpacing: 200,
            hooks: IHooks(hook)
        });

        // V4 approach: Get actual pool state using StateView
        PoolId poolId = PoolId.wrap(keccak256(abi.encode(poolKey)));
        poolIdBytes = PoolId.unwrap(poolId);

        try stateView.getSlot0(poolId) returns (uint160 sqrtPriceX96, int24, uint24, uint24) {
            sqrtPrice = sqrtPriceX96;

            if (sqrtPriceX96 > 0) {
                uint256 sqrtPriceX96_uint = uint256(sqrtPriceX96);
                uint256 q96 = 2**96;

                uint256 scaledDivisor = (q96 * 1e18) / sqrtPriceX96_uint;
                calculatedPrice = (scaledDivisor * q96) / sqrtPriceX96_uint; // finalPrice

                // Market Cap = price * totalSupply
                uint256 totalSupply = IERC20(tokenAddress).totalSupply();
                marketCapETH = calculatedPrice * totalSupply/1e18;

                return (poolIdBytes, sqrtPrice, calculatedPrice, marketCapETH);
            }
        } catch {
            // Pool doesn't exist - return 0
            return (poolIdBytes, 0, 0, 0);
        }

        return (poolIdBytes, 0, 0, 0);
    }

    function getMarketCap(address tokenAddress) public view returns (uint256 marketCapETH) {
        (, , , marketCapETH) = getTokenPrice(tokenAddress);
        return marketCapETH;
    }
    
    // Get total fees generated by a specific token
    function getTokenFeesGenerated(address tokenAddress) public view returns (uint256) {
        return tokenFeesGenerated[tokenAddress];
    }
}

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

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract Token is ERC20, ERC20Burnable {
    address public platform;
    address public creator;
    address private _owner;
    uint256 private launchBlock;
    uint256 private maxTxAmount;
    uint256 private immutable LAUNCH_PERIOD;
    uint256 private constant MAX_WALLET_PERCENTAGE = 2; // 2% of total supply

    address immutable pool = 0x8366a39CC670B4001A1121B8F6A443A643e40951; // Robinhood Chain PoolManager

    // Track transfers per tx.origin per block to detect multi-swaps
    mapping(address => uint256) private tokensFromPoolPerOrigin;

    event FeesReceived(uint256 amount);

    constructor(
        string memory _name,
        string memory _symbol,
        address _creator,
        address _platform,
        uint256 _launchPeriod
    ) ERC20(_name, _symbol) {
        platform = _platform;
        creator = _creator;
        _owner = address(0);
        launchBlock = block.number;
        LAUNCH_PERIOD = _launchPeriod;

        uint256 totalTokens = 1000000000 * 10 ** decimals();
        maxTxAmount = (totalTokens * MAX_WALLET_PERCENTAGE) / 100;

        _mint(_platform, totalTokens);
    }

    function _update(address from, address to, uint256 value) internal override {
        if (block.number > launchBlock && block.number <= launchBlock + LAUNCH_PERIOD) {
            // Get pool address for exemption

            if (from == pool && to != platform && to != creator) {
                tokensFromPoolPerOrigin[tx.origin] += value;
                require(
                    tokensFromPoolPerOrigin[tx.origin] <= maxTxAmount*110/100,
                    "Keeping 2% pool Limits In Kontrol"
                );
            }

            if (to != creator && to != platform && to != pool && from != address(0)) {
                require(
                    balanceOf(to) + value <= maxTxAmount,
                    "Max wallet limit exceeded during launch period"
                );
            }
        }

        // Block all buys at launch block except exempted transfers
        if (block.number == launchBlock &&
            from != address(0) &&
            to != platform &&
            from != platform &&
            !(from == platform && to == creator)) { // Only platform can send to creator
            revert("No buys allowed during launch block!");
        }

        super._update(from, to, value);
    }

    function isLaunchPeriodActive() public view returns (bool) {
        return block.number <= launchBlock + LAUNCH_PERIOD;
    }

    // Returns address(0) so on-chain tools (Etherscan, token scanners) report ownership
    // as renounced. _owner is hardcoded to zero in the constructor and is never reassignable.
    function owner() public view returns (address) {
        return _owner;
    }

    // Receive ETH from hook fees
    receive() external payable {
        emit FeesReceived(msg.value);
    }

    // Allow only Factory to withdraw accumulated fees
    function withdrawFees() external returns (uint256 balance) {
        require(msg.sender == platform, "Only factory can withdraw");
        balance = address(this).balance;
        require(balance > 0, "No fees to withdraw");

        (bool success, ) = payable(platform).call{value: balance}("");
        require(success, "Fee withdrawal failed");
    }

    function changeCreator(address newCreator) external {
        require(msg.sender == platform, "Only platform can change creator"); // Updating Fee Receiver
        creator = newCreator;
    }
}

Contract ABI

[
 {
  "type": "constructor",
  "inputs": [
   {
    "name": "_name",
    "type": "string",
    "internalType": "string"
   },
   {
    "name": "_symbol",
    "type": "string",
    "internalType": "string"
   },
   {
    "name": "_creator",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "_platform",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "_launchPeriod",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "stateMutability": "nonpayable"
 },
 {
  "name": "ERC20InsufficientAllowance",
  "type": "error",
  "inputs": [
   {
    "name": "spender",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "allowance",
    "type": "uint256",
    "internalType": "uint256"
   },
   {
    "name": "needed",
    "type": "uint256",
    "internalType": "uint256"
   }
  ]
 },
 {
  "name": "ERC20InsufficientBalance",
  "type": "error",
  "inputs": [
   {
    "name": "sender",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "balance",
    "type": "uint256",
    "internalType": "uint256"
   },
   {
    "name": "needed",
    "type": "uint256",
    "internalType": "uint256"
   }
  ]
 },
 {
  "name": "ERC20InvalidApprover",
  "type": "error",
  "inputs": [
   {
    "name": "approver",
    "type": "address",
    "internalType": "address"
   }
  ]
 },
 {
  "name": "ERC20InvalidReceiver",
  "type": "error",
  "inputs": [
   {
    "name": "receiver",
    "type": "address",
    "internalType": "address"
   }
  ]
 },
 {
  "name": "ERC20InvalidSender",
  "type": "error",
  "inputs": [
   {
    "name": "sender",
    "type": "address",
    "internalType": "address"
   }
  ]
 },
 {
  "name": "ERC20InvalidSpender",
  "type": "error",
  "inputs": [
   {
    "name": "spender",
    "type": "address",
    "internalType": "address"
   }
  ]
 },
 {
  "name": "Approval",
  "type": "event",
  "inputs": [
   {
    "name": "owner",
    "type": "address",
    "indexed": true,
    "internalType": "address"
   },
   {
    "name": "spender",
    "type": "address",
    "indexed": true,
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "indexed": false,
    "internalType": "uint256"
   }
  ],
  "anonymous": false
 },
 {
  "name": "FeesReceived",
  "type": "event",
  "inputs": [
   {
    "name": "amount",
    "type": "uint256",
    "indexed": false,
    "internalType": "uint256"
   }
  ],
  "anonymous": false
 },
 {
  "name": "Transfer",
  "type": "event",
  "inputs": [
   {
    "name": "from",
    "type": "address",
    "indexed": true,
    "internalType": "address"
   },
   {
    "name": "to",
    "type": "address",
    "indexed": true,
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "indexed": false,
    "internalType": "uint256"
   }
  ],
  "anonymous": false
 },
 {
  "name": "allowance",
  "type": "function",
  "inputs": [
   {
    "name": "owner",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "spender",
    "type": "address",
    "internalType": "address"
   }
  ],
  "outputs": [
   {
    "name": "",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "approve",
  "type": "function",
  "inputs": [
   {
    "name": "spender",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "outputs": [
   {
    "name": "",
    "type": "bool",
    "internalType": "bool"
   }
  ],
  "stateMutability": "nonpayable"
 },
 {
  "name": "balanceOf",
  "type": "function",
  "inputs": [
   {
    "name": "account",
    "type": "address",
    "internalType": "address"
   }
  ],
  "outputs": [
   {
    "name": "",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "burn",
  "type": "function",
  "inputs": [
   {
    "name": "value",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "outputs": [],
  "stateMutability": "nonpayable"
 },
 {
  "name": "burnFrom",
  "type": "function",
  "inputs": [
   {
    "name": "account",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "outputs": [],
  "stateMutability": "nonpayable"
 },
 {
  "name": "changeCreator",
  "type": "function",
  "inputs": [
   {
    "name": "newCreator",
    "type": "address",
    "internalType": "address"
   }
  ],
  "outputs": [],
  "stateMutability": "nonpayable"
 },
 {
  "name": "creator",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "address",
    "internalType": "address"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "decimals",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "uint8",
    "internalType": "uint8"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "isLaunchPeriodActive",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "bool",
    "internalType": "bool"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "name",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "string",
    "internalType": "string"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "owner",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "address",
    "internalType": "address"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "platform",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "address",
    "internalType": "address"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "symbol",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "string",
    "internalType": "string"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "totalSupply",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "stateMutability": "view"
 },
 {
  "name": "transfer",
  "type": "function",
  "inputs": [
   {
    "name": "to",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "outputs": [
   {
    "name": "",
    "type": "bool",
    "internalType": "bool"
   }
  ],
  "stateMutability": "nonpayable"
 },
 {
  "name": "transferFrom",
  "type": "function",
  "inputs": [
   {
    "name": "from",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "to",
    "type": "address",
    "internalType": "address"
   },
   {
    "name": "value",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "outputs": [
   {
    "name": "",
    "type": "bool",
    "internalType": "bool"
   }
  ],
  "stateMutability": "nonpayable"
 },
 {
  "name": "withdrawFees",
  "type": "function",
  "inputs": [],
  "outputs": [
   {
    "name": "balance",
    "type": "uint256",
    "internalType": "uint256"
   }
  ],
  "stateMutability": "nonpayable"
 },
 {
  "type": "receive",
  "stateMutability": "payable"
 }
]

Creation code isn’t shown — this contract was deployed by a factory (internal CREATE), so it has no standalone creation transaction.

Deployed Bytecode

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

Loading…

10,000+ event logs emitted by this contract

Txn Hash	Age	Event	Topics / Data
0x9fc1ae…8cdbd7	35 days agoTue, 14 Jul 2026 01:08:06 UTC	Transfer	[0] 0x000000000000…05140dd7 [1] 0x000000000000…43e40951 data: 0x000000000000000000…e7ffd9b1
0x9fc1ae…8cdbd7	35 days agoTue, 14 Jul 2026 01:08:06 UTC	Approval	[0] 0x000000000000…05140dd7 [1] 0x000000000000…3ac78ba3 data: 0xffffffffffffffffff…ffffffff
0x9fc1ae…8cdbd7	35 days agoTue, 14 Jul 2026 01:08:06 UTC	Transfer	[0] 0x000000000000…00000000 [1] 0x000000000000…05140dd7 data: 0x000000000000000000…e8000000

First‹Page 1 of 1›Last

Show:Records

Loading…

Token	Symbol	Balance	Price	Value
no token holdings

A contract address hosts a smart contract — a set of code functions that can execute independently of any centralized server. Learn more in our Knowledge Base.

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 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780

pragma solidity ^0.8.20; /* __ _ _ ____ __ _ _____ ____ ____ ____ ____ __ ___ | |/ ]| | | || |/ ] | || || \ / || \ / ] / _] | ' / | | | | | ' / | __| | | | _ || o || _ | / / / [_ | \ | |___ | | | \ | |_ | | | | || || | |/ / | _] | \| | | | | \ __ | _] | | | | || _ || | / \_ | [_ | . || | | | | . || || | | | | | || | || | \ || | |__|\_||_____||____||__|\_||__||__| |____||__|__||__|__||__|__|\____||_____| V4 Edition https://klik.finance https://x.com/klik_evm */ pragma solidity >=0.8.9; import {SwapParams} from "v4-core/src/types/PoolOperation.sol"; import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol"; import {PoolKey} from "v4-core/src/types/PoolKey.sol"; import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol"; import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol"; import {IHooks} from "v4-core/src/interfaces/IHooks.sol"; import {Hooks} from "v4-core/src/libraries/Hooks.sol"; import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol"; import {TickMath} from "v4-core/src/libraries/TickMath.sol"; import {IPositionManager} from "v4-periphery/src/interfaces/IPositionManager.sol"; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import {Actions} from "v4-periphery/src/libraries/Actions.sol"; import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol"; import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol"; interface IStateView { function getSlot0(PoolId poolId) external view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee); } import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol"; import {LPFeeLibrary} from "@uniswap/v4-core/src/libraries/LPFeeLibrary.sol"; import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol"; import {IV4Router} from "@uniswap/v4-periphery/src/interfaces/IV4Router.sol"; import {IPermit2} from "permit2/src/interfaces/IPermit2.sol"; import {Commands} from "@uniswap/universal-router/contracts/libraries/Commands.sol"; import "v4-core/test/utils/LiquidityAmounts.sol"; interface IToken { function creator() external view returns (address); function withdrawFees() external returns (uint256); } interface IWETH { function withdraw(uint256 amount) external; } contract Factory is ReentrancyGuard { event ERC20TokenCreated(address tokenAddress); struct TokenInfo { address tokenAddress; string name; string symbol; address deployer; uint256 time; string metadata; uint256 marketCapInETH; uint256 totalFeesGenerated; } mapping(uint256 => TokenInfo) public deployedTokens; mapping(address => TokenInfo) public tokenInfoByAddress; uint256 public tokenCount = 0; address public platformController; address public klikHook; // Universal hook for all tokens (can be updated) uint256 private itemsPerPage = 250; // Configurable items per page for pagination // Mapping to store token addresses by creator/deployer mapping(address => address[]) public creatorTokens; // Mapping to track total fees generated per token mapping(address => uint256) public tokenFeesGenerated; // Mapping to store the hook address used at deploy time per token mapping(address => address) public tokenHook; // Uniswap v4 deployment addresses — Robinhood Chain (chain ID 4663) IAllowanceTransfer constant PERMIT2 = IAllowanceTransfer(address(0x000000000022D473030F116dDEE9F6B43aC78BA3)); address public constant POSITION_MANAGER = 0x58daec3116aae6D93017bAAea7749052E8a04fA7; IPositionManager positionManager = IPositionManager(POSITION_MANAGER); address public constant POOL_MANAGER = 0x8366a39CC670B4001A1121B8F6A443A643e40951; IPoolManager poolManager = IPoolManager(POOL_MANAGER); address public constant STATE_VIEW = 0xF3334192D15450CdD385c8B70e03f9A6bD9E673b; IStateView stateView = IStateView(STATE_VIEW); uint256 constant Q96 = 2 ** 96; address public constant WETH = 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73; // Canonical WETH on Robinhood Chain address public constant UNIVERSAL_ROUTER = 0x8876789976dEcBfCbBbe364623C63652db8C0904; IUniversalRouter router = IUniversalRouter(UNIVERSAL_ROUTER); uint24 private constant FEE_TIER = 0; bool public deployCoinEnabled = true; // Liquidity configuration struct struct LiquidityConfig { uint160 sqrtPriceX96; // sqrtPriceX96 for the pool (address(0) is always currency0) int24 tickLower; // Lower tick for the position int24 tickUpper; // Upper tick for the position uint256 amount0Desired; // Desired amount of currency0 (ETH) uint256 amount1Desired; // Desired amount of currency1 (Token) uint256 virtualAmount; // Virtual ETH amount for market cap calculation uint256 penaltyMultiplier; // Penalty multiplier (50 = 50%, 100 = 100%, 200 = 200%) } // Multiple liquidity configurations mapping(uint256 => LiquidityConfig) public liquidityConfigs; uint256 public liquidityConfigCount = 0; uint256 public launchPeriod = 300; // blocks; set to 0 to disable max-wallet restrictions event TokenPurchased(address buyer, address tokenOut, uint256 ethSpent, uint256 tokensReceived); event KlikHookUpdated(address oldHook, address newHook); constructor(address _klikHook) { platformController = msg.sender; klikHook = _klikHook; // Pre-seeded liquidity configurations (IDs 0-4). All single-sided: // full 1B token supply, no ETH. virtualAmount = starting market cap // in ETH; sqrtPriceX96 prices the full supply at exactly that amount. // penaltyMultiplier 0 = no deploy-buy tax (100 = standard penalty). // ID 0: 0.69 ETH virtual liquidity (default) liquidityConfigs[0] = LiquidityConfig({ sqrtPriceX96: 3014831488601586337191090825970934, tickLower: -887200, tickUpper: 210800, amount0Desired: 0, amount1Desired: 1000000000000000000000000000, virtualAmount: 690000000000000000, penaltyMultiplier: 0 }); // ID 1: 1 ETH virtual liquidity liquidityConfigs[1] = LiquidityConfig({ sqrtPriceX96: 2505411999795360582221170761428213, tickLower: -887200, tickUpper: 207200, amount0Desired: 0, amount1Desired: 1000000000000000000000000000, virtualAmount: 1000000000000000000, penaltyMultiplier: 0 }); // ID 2: 2 ETH virtual liquidity liquidityConfigs[2] = LiquidityConfig({ sqrtPriceX96: 1771577727172025373304338615273325, tickLower: -887200, tickUpper: 200200, amount0Desired: 0, amount1Desired: 1000000000000000000000000000, virtualAmount: 2000000000000000000, penaltyMultiplier: 0 }); // ID 3: 5 ETH virtual liquidity liquidityConfigs[3] = LiquidityConfig({ sqrtPriceX96: 1120408587790087695236213992013890, tickLower: -887200, tickUpper: 191000, amount0Desired: 0, amount1Desired: 1000000000000000000000000000, virtualAmount: 5000000000000000000, penaltyMultiplier: 0 }); // ID 4: 10 ETH virtual liquidity liquidityConfigs[4] = LiquidityConfig({ sqrtPriceX96: 792280926924313289846529216293289, tickLower: -887200, tickUpper: 184200, amount0Desired: 0, amount1Desired: 1000000000000000000000000000, virtualAmount: 10000000000000000000, penaltyMultiplier: 0 }); liquidityConfigCount = 5; } function setKlikHook(address _newHook) external { require(msg.sender == platformController, "Caller is not controller"); address oldHook = klikHook; klikHook = _newHook; emit KlikHookUpdated(oldHook, _newHook); } function setLaunchPeriod(uint256 _blocks) external { require(msg.sender == platformController, "Caller is not controller"); launchPeriod = _blocks; } receive() external payable {} function deployCoin(string memory _name, string memory _symbol, string memory _metadata, bytes32 salt, uint256 configId) public payable returns (uint256 tokensReceived) { require(deployCoinEnabled, "Token deployment is currently disabled"); require(configId < liquidityConfigCount, "Invalid liquidity config ID"); Token t = new Token{salt: salt}( _name, _symbol, msg.sender, address(this), launchPeriod ); address coin_address = address(t); emit ERC20TokenCreated(coin_address); provideLiquidityV4(coin_address, configId); tokensReceived = 0; // Initialize return value if (msg.value > 0) { LiquidityConfig memory config = liquidityConfigs[configId]; uint256 basePenalty = getPenalty(msg.value); // in basis points (e.g., 2500 = 25%) uint256 taxBps = (basePenalty * config.penaltyMultiplier) / 100; // Apply config multiplier uint256 tax; uint256 amountAfterTax; // Assembly optimized math operations unchecked { assembly { tax := div(mul(callvalue(), taxBps), 10000) amountAfterTax := sub(callvalue(), tax) } } uint256 tokensBefore = IERC20(coin_address).balanceOf(address(this)); _buyToken(coin_address, amountAfterTax); uint256 tokensAfter = IERC20(coin_address).balanceOf(address(this)); tokensReceived = tokensAfter - tokensBefore; // Transfer tokens to buyer IERC20(coin_address).transfer(msg.sender, tokensReceived); emit TokenPurchased(msg.sender, coin_address, amountAfterTax, tokensReceived); } // Cache tokenCount to avoid multiple SLOAD operations uint256 currentTokenCount = tokenCount; TokenInfo memory newTokenInfo = TokenInfo({ tokenAddress: coin_address, name: _name, symbol: _symbol, deployer: msg.sender, time: block.timestamp, metadata: _metadata, marketCapInETH: 0, totalFeesGenerated: 0 }); deployedTokens[currentTokenCount] = newTokenInfo; tokenInfoByAddress[coin_address] = newTokenInfo; tokenHook[coin_address] = klikHook; // Add token to creator's array creatorTokens[msg.sender].push(coin_address); // Assembly optimized increment (unchecked) assembly { sstore(tokenCount.slot, add(currentTokenCount, 1)) } return tokensReceived; } // Returns the exact init_code that deployCoin will use, so frontends can // compute the CREATE2 address for a given salt before submitting the tx. // launchPeriod is read from current state — callers must re-read this if // the controller changes launchPeriod between salt-mining and deploy, or // the predicted address will diverge from the actual one. function getTokenBytecode( string memory _name, string memory _symbol, address creator ) public view returns (bytes memory bytecode) { bytecode = abi.encodePacked( type(Token).creationCode, abi.encode(_name, _symbol, creator, address(this), launchPeriod) ); } function getPenalty(uint256 ethAmount) public pure returns (uint256) { if (ethAmount < 0.05 ether) return 0; if (ethAmount >= 0.30 ether) return 5000; // max 50% uint256 slope = 18000; uint256 delta = ethAmount - 0.05 ether; uint256 penalty = 500 + (delta * slope) / 1 ether; return penalty; } function toggleDeployCoin() external { require(msg.sender == platformController, "Caller is not controller"); deployCoinEnabled = !deployCoinEnabled; } // Create new liquidity configuration function createLiquidityConfig( uint160 _sqrtPriceX96, int24 _tickLower, int24 _tickUpper, uint256 _amount0Desired, uint256 _amount1Desired, uint256 _virtualAmount, uint256 _penaltyMultiplier ) external returns (uint256 configId) { require(msg.sender == platformController, "Only platform controller can create liquidity config"); require(_penaltyMultiplier <= 500, "Penalty multiplier must be at most 500%"); configId = liquidityConfigCount; liquidityConfigs[configId] = LiquidityConfig({ sqrtPriceX96: _sqrtPriceX96, tickLower: _tickLower, tickUpper: _tickUpper, amount0Desired: _amount0Desired, amount1Desired: _amount1Desired, virtualAmount: _virtualAmount, penaltyMultiplier: _penaltyMultiplier }); liquidityConfigCount++; return configId; } // Update existing liquidity configuration function updateLiquidityConfig( uint256 _configId, uint160 _sqrtPriceX96, int24 _tickLower, int24 _tickUpper, uint256 _amount0Desired, uint256 _amount1Desired, uint256 _virtualAmount, uint256 _penaltyMultiplier ) external { require(msg.sender == platformController, "Only platform controller can update liquidity config"); require(_configId < liquidityConfigCount, "Invalid config ID"); require(_penaltyMultiplier <= 500, "Penalty multiplier must be at most 500%"); liquidityConfigs[_configId] = LiquidityConfig({ sqrtPriceX96: _sqrtPriceX96, tickLower: _tickLower, tickUpper: _tickUpper, amount0Desired: _amount0Desired, amount1Desired: _amount1Desired, virtualAmount: _virtualAmount, penaltyMultiplier: _penaltyMultiplier }); } // Delete liquidity configuration (sets to zero values) function deleteLiquidityConfig(uint256 _configId) external { require(msg.sender == platformController, "Only platform controller can delete liquidity config"); require(_configId < liquidityConfigCount, "Invalid config ID"); require(_configId != 0, "Cannot delete default config"); delete liquidityConfigs[_configId]; } // Get liquidity configuration function getLiquidityConfig(uint256 _configId) external view returns (LiquidityConfig memory) { require(_configId < liquidityConfigCount, "Invalid config ID"); return liquidityConfigs[_configId]; } // Change the number of items per page for pagination function setItemsPerPage(uint256 _itemsPerPage) external { require(msg.sender == platformController, "Only platform controller can change items per page"); require(_itemsPerPage > 0 && _itemsPerPage <= 1000, "Items per page must be between 1 and 1000"); itemsPerPage = _itemsPerPage; } // Get all tokens for a creator in one call function getAllTokensByCreator(address _creator) public view returns (address[] memory) { return creatorTokens[_creator]; } function getDeploysByPage(uint256 page, uint256 order) public view returns (TokenInfo[] memory) { require(tokenCount > 0, "No tokens deployed"); uint256 totalPages = (tokenCount + itemsPerPage - 1) / itemsPerPage; require(page < totalPages, "Page out of range"); uint256 start; uint256 end; uint256 j = 0; if (order == 0) { // Newest first start = tokenCount > (page + 1) * itemsPerPage ? tokenCount - (page + 1) * itemsPerPage : 0; end = tokenCount - page * itemsPerPage; if (end > tokenCount) end = tokenCount; } else { // Oldest first start = page * itemsPerPage; end = start + itemsPerPage; if (end > tokenCount) end = tokenCount; } TokenInfo[] memory tokens = new TokenInfo[](end - start); for (uint256 i = start; i < end; i++) { uint256 index = order == 0 ? end - 1 - (i - start) : i; TokenInfo memory info = deployedTokens[index]; // Calculate market cap using the correct formula uint256 marketCap = getMarketCap(info.tokenAddress); tokens[j++] = TokenInfo({ tokenAddress: info.tokenAddress, name: info.name, symbol: info.symbol, deployer: info.deployer, time: info.time, metadata: info.metadata, marketCapInETH: marketCap, totalFeesGenerated: tokenFeesGenerated[info.tokenAddress] }); } return tokens; } function withdrawFeesWETH() external { require(msg.sender == platformController, "Caller is not controller"); uint256 wethBalance = IERC20(WETH).balanceOf(address(this)); require(wethBalance > 0, "No WETH to withdraw"); IWETH(WETH).withdraw(wethBalance); (bool success, ) = msg.sender.call{value: wethBalance}(""); require(success, "ETH transfer failed"); } function withdrawFeesETH() external { require(msg.sender == platformController, "Caller is not controller"); uint256 ethBalance = address(this).balance; require(ethBalance > 0, "No ETH to withdraw"); (bool success, ) = msg.sender.call{value: ethBalance}(""); require(success, "ETH transfer failed"); } function provideLiquidityV4(address tokenA, uint256 configId) internal { LiquidityConfig memory config = liquidityConfigs[configId]; // Since address(0) is always < any token address, it's always currency0 // No need for complex comparison logic IERC20 token = IERC20(tokenA); token.approve(address(PERMIT2), type(uint256).max); PERMIT2.approve(tokenA, address(POSITION_MANAGER), type(uint160).max, type(uint48).max); PERMIT2.approve(tokenA, address(POOL_MANAGER), type(uint160).max, type(uint48).max); PoolKey memory pool = PoolKey({ currency0: Currency.wrap(address(0)), // ETH is always currency0 currency1: Currency.wrap(address(tokenA)), // Token is always currency1 fee: 0, tickSpacing: 200, hooks: IHooks(klikHook) // Use universal hook }); poolManager.initialize(pool, config.sqrtPriceX96); uint128 liquidity = _calculateLiquidity( config.sqrtPriceX96, config.tickLower, config.tickUpper, config.amount0Desired, config.amount1Desired ); bytes memory actions = abi.encodePacked(uint8(Actions.MINT_POSITION), uint8(Actions.SETTLE_PAIR)); bytes memory hookData = new bytes(0); bytes[] memory params = new bytes[](2); params[0] = abi.encode( pool, config.tickLower, config.tickUpper, liquidity, config.amount0Desired, config.amount1Desired, address(0x000000000000000000000000000000000000dEaD), // LP burned — no removal functions exist in this factory anyway; burning makes the lock verifiable on-chain hookData ); params[1] = abi.encode(pool.currency0, pool.currency1); try positionManager.modifyLiquidities( abi.encode(actions, params), block.timestamp + 120 ) { // Successfully added liquidity } catch (bytes memory reason) { assembly { revert(add(reason, 0x20), mload(reason)) } } } function _calculateLiquidity( uint160 sqrtPriceX96, int24 tickLower, int24 tickUpper, uint256 amount0Desired, uint256 amount1Desired ) private pure returns (uint128) { return LiquidityAmounts.getLiquidityForAmounts( sqrtPriceX96, TickMath.getSqrtPriceAtTick(tickLower), TickMath.getSqrtPriceAtTick(tickUpper), amount0Desired, amount1Desired ); } // Mirror of IV4Router.ExactInputSingleParams, declared locally so its // poolKey field uses THIS file's PoolKey type. Referencing IV4Router's // struct directly fails to compile: its PoolKey comes from a different // import path (@uniswap/v4-core) than the factory's (v4-core), and Solidity // treats the two as distinct types. The ABI layout is identical, which is // all the Universal Router's CalldataDecoder reads. struct ExactInputSingleParams { PoolKey poolKey; bool zeroForOne; uint128 amountIn; uint128 amountOutMinimum; bytes hookData; } function _buyToken(address tokenAddress, uint256 ethAmount) internal { // Create PoolKey for ETH -> Token swap PoolKey memory pool = PoolKey({ currency0: Currency.wrap(address(0)), // ETH currency1: Currency.wrap(tokenAddress), // New token fee: 0, tickSpacing: 200, hooks: IHooks(klikHook) // Use universal hook }); // Encode the Universal Router command bytes memory commands = abi.encodePacked(uint8(Commands.V4_SWAP)); bytes[] memory inputs = new bytes[](1); // Encode V4Router actions bytes memory actions = abi.encodePacked( uint8(Actions.SWAP_EXACT_IN_SINGLE), uint8(Actions.SETTLE_ALL), uint8(Actions.TAKE_ALL) ); // Prepare parameters for each action. // params[0] MUST be the ExactInputSingleParams struct (not its fields // spread out) — the struct encoding carries a leading offset word that // the Universal Router's CalldataDecoder requires. Spreading the fields // omits that word and reverts SliceOutOfBounds() on current UR builds. bytes[] memory params = new bytes[](3); params[0] = abi.encode( ExactInputSingleParams({ poolKey: pool, zeroForOne: true, // ETH (currency0) -> Token (currency1) amountIn: uint128(ethAmount), amountOutMinimum: uint128(0), // 0 = no minimum requirement hookData: bytes("") }) ); params[1] = abi.encode(pool.currency0, ethAmount); // SETTLE_ALL params params[2] = abi.encode(pool.currency1, uint128(0)); // TAKE_ALL params // Combine actions and params into inputs inputs[0] = abi.encode(actions, params); // Execute the swap uint256 deadline = block.timestamp + 120; router.execute{value: ethAmount}(commands, inputs, deadline); // Tokens remain in contract - caller handles transfer and event emission } function collectFees(address tokenAddress) external nonReentrant returns (uint256 ethCollected) { address creator = IToken(tokenAddress).creator(); require(msg.sender == creator || msg.sender == platformController, "Not authorized"); uint256 balanceBefore = address(this).balance; IToken(tokenAddress).withdrawFees(); uint256 balanceAfter = address(this).balance; ethCollected = balanceAfter - balanceBefore; if (ethCollected > 0) { tokenFeesGenerated[tokenAddress] += ethCollected; // Platform share is taken atomically by the hook at swap time. // Everything in the token contract is the creator's portion. (bool success, ) = payable(creator).call{value: ethCollected}(""); require(success, "ETH transfer to creator failed"); } return ethCollected; } function changeTokenFeeReceiver(address tokenAddress, address newCreator) external { address currentCreator = IToken(tokenAddress).creator(); require(msg.sender == platformController || msg.sender == currentCreator, "Not authorized"); require(newCreator != address(0), "New creator cannot be zero address"); Token(payable(tokenAddress)).changeCreator(newCreator); } function getTokenPrice(address tokenAddress) public view returns (bytes32 poolIdBytes, uint160 sqrtPrice, uint256 calculatedPrice, uint256 marketCapETH) { // Create PoolKey for ETH/Token pool address hook = tokenHook[tokenAddress] != address(0) ? tokenHook[tokenAddress] : klikHook; PoolKey memory poolKey = PoolKey({ currency0: Currency.wrap(address(0)), // ETH currency1: Currency.wrap(tokenAddress), // Token fee: 0, tickSpacing: 200, hooks: IHooks(hook) }); // V4 approach: Get actual pool state using StateView PoolId poolId = PoolId.wrap(keccak256(abi.encode(poolKey))); poolIdBytes = PoolId.unwrap(poolId); try stateView.getSlot0(poolId) returns (uint160 sqrtPriceX96, int24, uint24, uint24) { sqrtPrice = sqrtPriceX96; if (sqrtPriceX96 > 0) { uint256 sqrtPriceX96_uint = uint256(sqrtPriceX96); uint256 q96 = 2**96; uint256 scaledDivisor = (q96 * 1e18) / sqrtPriceX96_uint; calculatedPrice = (scaledDivisor * q96) / sqrtPriceX96_uint; // finalPrice // Market Cap = price * totalSupply uint256 totalSupply = IERC20(tokenAddress).totalSupply(); marketCapETH = calculatedPrice * totalSupply/1e18; return (poolIdBytes, sqrtPrice, calculatedPrice, marketCapETH); } } catch { // Pool doesn't exist - return 0 return (poolIdBytes, 0, 0, 0); } return (poolIdBytes, 0, 0, 0); } function getMarketCap(address tokenAddress) public view returns (uint256 marketCapETH) { (, , , marketCapETH) = getTokenPrice(tokenAddress); return marketCapETH; } // Get total fees generated by a specific token function getTokenFeesGenerated(address tokenAddress) public view returns (uint256) { return tokenFeesGenerated[tokenAddress]; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract Token is ERC20, ERC20Burnable { address public platform; address public creator; address private _owner; uint256 private launchBlock; uint256 private maxTxAmount; uint256 private immutable LAUNCH_PERIOD; uint256 private constant MAX_WALLET_PERCENTAGE = 2; // 2% of total supply address immutable pool = 0x8366a39CC670B4001A1121B8F6A443A643e40951; // Robinhood Chain PoolManager // Track transfers per tx.origin per block to detect multi-swaps mapping(address => uint256) private tokensFromPoolPerOrigin; event FeesReceived(uint256 amount); constructor( string memory _name, string memory _symbol, address _creator, address _platform, uint256 _launchPeriod ) ERC20(_name, _symbol) { platform = _platform; creator = _creator; _owner = address(0); launchBlock = block.number; LAUNCH_PERIOD = _launchPeriod; uint256 totalTokens = 1000000000 * 10 ** decimals(); maxTxAmount = (totalTokens * MAX_WALLET_PERCENTAGE) / 100; _mint(_platform, totalTokens); } function _update(address from, address to, uint256 value) internal override { if (block.number > launchBlock && block.number <= launchBlock + LAUNCH_PERIOD) { // Get pool address for exemption if (from == pool && to != platform && to != creator) { tokensFromPoolPerOrigin[tx.origin] += value; require( tokensFromPoolPerOrigin[tx.origin] <= maxTxAmount*110/100, "Keeping 2% pool Limits In Kontrol" ); } if (to != creator && to != platform && to != pool && from != address(0)) { require( balanceOf(to) + value <= maxTxAmount, "Max wallet limit exceeded during launch period" ); } } // Block all buys at launch block except exempted transfers if (block.number == launchBlock && from != address(0) && to != platform && from != platform && !(from == platform && to == creator)) { // Only platform can send to creator revert("No buys allowed during launch block!"); } super._update(from, to, value); } function isLaunchPeriodActive() public view returns (bool) { return block.number <= launchBlock + LAUNCH_PERIOD; } // Returns address(0) so on-chain tools (Etherscan, token scanners) report ownership // as renounced. _owner is hardcoded to zero in the constructor and is never reassignable. function owner() public view returns (address) { return _owner; } // Receive ETH from hook fees receive() external payable { emit FeesReceived(msg.value); } // Allow only Factory to withdraw accumulated fees function withdrawFees() external returns (uint256 balance) { require(msg.sender == platform, "Only factory can withdraw"); balance = address(this).balance; require(balance > 0, "No fees to withdraw"); (bool success, ) = payable(platform).call{value: balance}(""); require(success, "Fee withdrawal failed"); } function changeCreator(address newCreator) external { require(msg.sender == platform, "Only platform can change creator"); // Updating Fee Receiver creator = newCreator; } }

[ { "type": "constructor", "inputs": [ { "name": "_name", "type": "string", "internalType": "string" }, { "name": "_symbol", "type": "string", "internalType": "string" }, { "name": "_creator", "type": "address", "internalType": "address" }, { "name": "_platform", "type": "address", "internalType": "address" }, { "name": "_launchPeriod", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "nonpayable" }, { "name": "ERC20InsufficientAllowance", "type": "error", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "allowance", "type": "uint256", "internalType": "uint256" }, { "name": "needed", "type": "uint256", "internalType": "uint256" } ] }, { "name": "ERC20InsufficientBalance", "type": "error", "inputs": [ { "name": "sender", "type": "address", "internalType": "address" }, { "name": "balance", "type": "uint256", "internalType": "uint256" }, { "name": "needed", "type": "uint256", "internalType": "uint256" } ] }, { "name": "ERC20InvalidApprover", "type": "error", "inputs": [ { "name": "approver", "type": "address", "internalType": "address" } ] }, { "name": "ERC20InvalidReceiver", "type": "error", "inputs": [ { "name": "receiver", "type": "address", "internalType": "address" } ] }, { "name": "ERC20InvalidSender", "type": "error", "inputs": [ { "name": "sender", "type": "address", "internalType": "address" } ] }, { "name": "ERC20InvalidSpender", "type": "error", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" } ] }, { "name": "Approval", "type": "event", "inputs": [ { "name": "owner", "type": "address", "indexed": true, "internalType": "address" }, { "name": "spender", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "FeesReceived", "type": "event", "inputs": [ { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "Transfer", "type": "event", "inputs": [ { "name": "from", "type": "address", "indexed": true, "internalType": "address" }, { "name": "to", "type": "address", "indexed": true, "internalType": "address" }, { "name": "value", "type": "uint256", "indexed": false, "internalType": "uint256" } ], "anonymous": false }, { "name": "allowance", "type": "function", "inputs": [ { "name": "owner", "type": "address", "internalType": "address" }, { "name": "spender", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "approve", "type": "function", "inputs": [ { "name": "spender", "type": "address", "internalType": "address" }, { "name": "value", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "balanceOf", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" } ], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "burn", "type": "function", "inputs": [ { "name": "value", "type": "uint256", "internalType": "uint256" } ], "outputs": [], "stateMutability": "nonpayable" }, { "name": "burnFrom", "type": "function", "inputs": [ { "name": "account", "type": "address", "internalType": "address" }, { "name": "value", "type": "uint256", "internalType": "uint256" } ], "outputs": [], "stateMutability": "nonpayable" }, { "name": "changeCreator", "type": "function", "inputs": [ { "name": "newCreator", "type": "address", "internalType": "address" } ], "outputs": [], "stateMutability": "nonpayable" }, { "name": "creator", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "address", "internalType": "address" } ], "stateMutability": "view" }, { "name": "decimals", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint8", "internalType": "uint8" } ], "stateMutability": "view" }, { "name": "isLaunchPeriodActive", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "view" }, { "name": "name", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "owner", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "address", "internalType": "address" } ], "stateMutability": "view" }, { "name": "platform", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "address", "internalType": "address" } ], "stateMutability": "view" }, { "name": "symbol", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "string", "internalType": "string" } ], "stateMutability": "view" }, { "name": "totalSupply", "type": "function", "inputs": [], "outputs": [ { "name": "", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "view" }, { "name": "transfer", "type": "function", "inputs": [ { "name": "to", "type": "address", "internalType": "address" }, { "name": "value", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "transferFrom", "type": "function", "inputs": [ { "name": "from", "type": "address", "internalType": "address" }, { "name": "to", "type": "address", "internalType": "address" }, { "name": "value", "type": "uint256", "internalType": "uint256" } ], "outputs": [ { "name": "", "type": "bool", "internalType": "bool" } ], "stateMutability": "nonpayable" }, { "name": "withdrawFees", "type": "function", "inputs": [], "outputs": [ { "name": "balance", "type": "uint256", "internalType": "uint256" } ], "stateMutability": "nonpayable" }, { "type": "receive", "stateMutability": "payable" } ]

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