ValidationLibrary

{{
  "language": "Solidity",
  "sources": {
    "ValidationLibrary.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
pragma solidity ^0.8.20;\r
\r
import "./ILaxcePadInterfaces.sol";\r
\r
/**\r
 * @title ValidationLibrary\r
 * @dev Library to reduce TokenFactory contract size by moving validation logic\r
 */\r
library ValidationLibrary {\r
    uint256 public constant MAX_NAME_LENGTH = 50;\r
    uint256 public constant MAX_SYMBOL_LENGTH = 10;\r
    uint256 public constant MAX_DESCRIPTION_LENGTH = 500;\r
    uint256 public constant MAX_SOCIAL_LINKS = 10;\r
\r
    error InvalidParams();\r
    error InvalidLen();\r
\r
    function validateTokenParams(ITokenFactory.TokenParams calldata params) external pure {\r
        validateStringParams(params);\r
        validateSupplyParams(params);\r
    }\r
\r
    function validateStringParams(ITokenFactory.TokenParams calldata params) public pure {\r
        validateName(params.name);\r
        validateSymbol(params.symbol);\r
        validateDescription(params.description);\r
        validateSocialLinks(params.socialLinks);\r
    }\r
\r
    function validateName(string calldata name) public pure {\r
        if (bytes(name).length == 0 || bytes(name).length > MAX_NAME_LENGTH) {\r
            revert InvalidLen();\r
        }\r
    }\r
\r
    function validateSymbol(string calldata symbol) public pure {\r
        if (bytes(symbol).length == 0 || bytes(symbol).length > MAX_SYMBOL_LENGTH) {\r
            revert InvalidLen();\r
        }\r
    }\r
\r
    function validateDescription(string calldata description) public pure {\r
        if (bytes(description).length > MAX_DESCRIPTION_LENGTH) {\r
            revert InvalidLen();\r
        }\r
    }\r
\r
    function validateSocialLinks(string[] calldata socialLinks) public pure {\r
        if (socialLinks.length > MAX_SOCIAL_LINKS) {\r
            revert InvalidParams();\r
        }\r
    }\r
\r
    function validateSupplyParams(ITokenFactory.TokenParams calldata params) public pure {\r
        validateTotalSupply(params.totalSupply);\r
        validateSupplyDistribution(params.totalSupply, params.bondingCurveSupply, params.liquiditySupply);\r
    }\r
\r
    function validateTotalSupply(uint256 totalSupply) public pure {\r
        if (totalSupply == 0) {\r
            revert InvalidParams();\r
        }\r
    }\r
\r
    function validateSupplyDistribution(\r
        uint256 totalSupply,\r
        uint256 bondingCurveSupply,\r
        uint256 liquiditySupply\r
    ) public pure {\r
        if (bondingCurveSupply > totalSupply) {\r
            revert InvalidParams();\r
        }\r
        if (liquiditySupply > totalSupply) {\r
            revert InvalidParams();\r
        }\r
        if (bondingCurveSupply + liquiditySupply > totalSupply) {\r
            revert InvalidParams();\r
        }\r
    }\r
\r
    function stringContains(string memory str, string memory substr) external pure returns (bool) {\r
        bytes memory strBytes = bytes(str);\r
        bytes memory substrBytes = bytes(substr);\r
\r
        if (substrBytes.length > strBytes.length) return false;\r
        if (substrBytes.length == 0) return true;\r
\r
        for (uint256 i = 0; i <= strBytes.length - substrBytes.length; i++) {\r
            bool found = true;\r
            for (uint256 j = 0; j < substrBytes.length; j++) {\r
                if (strBytes[i + j] != substrBytes[j]) {\r
                    found = false;\r
                    break;\r
                }\r
            }\r
            if (found) return true;\r
        }\r
\r
        return false;\r
    }\r
}\r
"
    },
    "ILaxcePadInterfaces.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface ITokenFactory {
    struct TokenParams {
        string name;
        string symbol;
        string description;
        string imageUrl;
        string[] socialLinks;
        uint256 totalSupply;
        uint256 bondingCurveSupply;
        uint256 liquiditySupply;
        uint256 creationFee;
    }

    function createToken(TokenParams calldata params) external payable returns (address token);
    function getTokenInfo(address token) external view returns (TokenParams memory);
    function isTokenCreated(address token) external view returns (bool);
}

interface IBondingCurve {
    struct CurveParams {
        uint256 startPrice;
        uint256 targetMarketCap;
        uint256 currentMarketCap;
        uint256 totalSupply;
        uint256 availableSupply;
        uint256 reserveETH;
        bool isGraduated;
    }

    function initializeCurve(
        address token,
        uint256 supply,
        uint256 startPrice,
        uint256 targetMarketCap
    ) external;

    function buy(address token, uint256 minTokensOut) external payable returns (uint256 tokensOut);
    function sell(address token, uint256 tokenAmount, uint256 minETHOut) external returns (uint256 ethOut);

    function getCurrentPrice(address token) external view returns (uint256);
    function getMarketCap(address token) external view returns (uint256);
    function canGraduate(address token) external view returns (bool);
    function graduateToken(address token) external returns (bool);

    event TokenBought(address indexed token, address indexed buyer, uint256 ethAmount, uint256 tokenAmount, uint256 newPrice);
    event TokenSold(address indexed token, address indexed seller, uint256 tokenAmount, uint256 ethAmount, uint256 newPrice);
    event CurveInitialized(address indexed token, uint256 supply, uint256 startPrice, uint256 targetMarketCap);
}

interface IGraduationManager {
    function graduateToken(address token) external returns (address pool);
    function isGraduated(address token) external view returns (bool);
    function getGraduatedPool(address token) external view returns (address);

    event TokenGraduated(address indexed token, address indexed pool, uint256 marketCap, uint256 liquidityAdded);
}

interface IRevenueDistribution {
    struct RevenueShare {
        address recipient;
        uint256 percentage;
        string description;
    }

    function distributeRevenue() external;
    function setRevenueShare(address recipient, uint256 percentage, string calldata description) external;
    function getRevenueShare(address recipient) external view returns (uint256);
    function getTotalRevenue() external view returns (uint256);

    event RevenueDistributed(uint256 totalAmount, uint256 timestamp);
    event RevenueShareUpdated(address indexed recipient, uint256 percentage);
}

interface ILaxcePadToken {
    function mint(address to, uint256 amount) external;
    function burn(uint256 amount) external;
    function setMetadata(string calldata description, string calldata imageUrl, string[] calldata socialLinks) external;
    function getMetadata() external view returns (string memory description, string memory imageUrl, string[] memory socialLinks);
    function creator() external view returns (address);
    function createdAt() external view returns (uint256);
}

interface IDEXIntegration {
    function getTokenRegistry() external view returns (address);
    function getPoolFactory() external view returns (address);
    function getDEXEngine() external view returns (address);
    function getCoreRegistry() external view returns (address);
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 100
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}