Smart Contract Interfaces

// SPDX-License-Identifier: BUSL-1.1
// Copyright (C) 2025 Beb, Inc. All Rights Reserved
pragma solidity ^0.8.27;

/**
 * @title IBoosterDropV2
 * @dev Interface for the BoosterDropV2 contract
 */
interface IBoosterDropV2 {
    // Rarity level constants
    // uint8 public constant RARITY_COMMON = 1;
    // uint8 public constant RARITY_RARE = 2;
    // uint8 public constant RARITY_EPIC = 3;
    // uint8 public constant RARITY_LEGENDARY = 4;
    // uint8 public constant RARITY_MYTHIC = 5;

    struct SequenceRequest {
        uint256 batchId;
        address recipient;
    }

    struct Rarity {
        uint8 rarity;
        uint256 randomValue;
        bytes32 tokenSpecificRandomness;
    }

    // Market type enum (should match IBoosterTokenV2's enum)
    enum MarketType {
        BONDING_CURVE,
        UNISWAP_POOL
    }

    // Events
    event RandomnessRequested(address indexed requester, uint256 batchId, uint64 sequenceNumber);
    event RandomnessFulfilled(uint64 sequsenceNumber, bytes32 randomNumber);
    event BoosterDropsMinted(address indexed minter, uint256 amount, uint256 startTokenId, uint256 endTokenId);
    event BoosterDropTransfer(address indexed from, address indexed to, uint256 tokenId);
    event BoosterDropSold(address indexed burner, uint256 tokenId, uint8 rarity, uint256 offerAmount);
    event BoosterDropSoldBatch(address indexed burner, uint256[] tokenIds, uint8[] rarities, uint256 finalOfferAmount);
    event BoosterDropOpened(address indexed from, uint256[] tokenIds, uint256 batchId);
    event RarityAssigned(uint256 batchId, bytes32 randomNumber);
    event EntropyAddressUpdated(address newEntropyAddress);
    event EntropyProviderUpdated(address newProvider);


    // Initialize parameters struct
    struct InitializeParams {
        address owner;
        string nftName;
        string nftSymbol;
        address tokenAddress;
        string baseURI;
        uint256 tokensPerMint;
        uint256 commonOffer;
        uint256 rareOffer;
        uint256 epicOffer;
        uint256 legendaryOffer;
        uint256 mythicOffer;
        address entropyAddress;
    }

    /**
     * @notice Initializes the contract
     * @param params All initialization parameters
     */
    function initialize(InitializeParams memory params) external;

    /**
     * @notice Mint multiple booster box LTCs (Liquid Trading Cards) with ETH
     * @param amount Number of LTCs (Liquid Trading Cards) to mint
     */
    function mint(uint256 amount) external payable;

    /**
     * @notice Mint multiple booster box LTCs (Liquid Trading Cards) with ETH
     * @param amount Number of LTCs (Liquid Trading Cards) to mint
     * @param recipient Address to receive the LTCs (Liquid Trading Cards)
     * @param referrer Address of the referrer
     * @param originReferrer Address of the origin referrer
     */
    function mint(uint256 amount, address recipient, address referrer, address originReferrer) external payable;

    /**
     * @notice Mint multiple booster box LTCs (Liquid Trading Cards) with tokens directly
     * @param amount Number of LTCs (Liquid Trading Cards) to mint
     */
    function mintWithToken(uint256 amount) external payable;

    /**
     * @notice Sells LTC (Liquid Trading Card) to contract and claims token offers based on rarity
     * @param tokenId Token ID to sell
     */
    function sellAndClaimOffer(uint256 tokenId) external;

    /**
     * @notice Get the token amount needed to mint a specific number of LTCs (Liquid Trading Cards)
     * @param amount Number of LTCs (Liquid Trading Cards) to mint
     * @return tokenAmount Total tokens required
     */
    function getMintPrice(uint256 amount) external view returns (uint256);

    /**
     * @notice Get the token amount needed per LTC (Liquid Trading Card) mint
     * @return The token amount per mint
     */
    function tokensPerMint() external view returns (uint256);

    /**
     * @notice Get the offer amount for a common rarity LTC (Liquid Trading Card)
     * @return The common offer amount
     */
    function COMMON_OFFER() external view returns (uint256);

    /**
     * @notice Get the offer amount for a rare rarity LTC (Liquid Trading Card)
     * @return The rare offer amount
     */
    function RARE_OFFER() external view returns (uint256);

    /**
     * @notice Get the offer amount for an epic rarity LTC (Liquid Trading Card)
     * @return The epic offer amount
     */
    function EPIC_OFFER() external view returns (uint256);

    /**
     * @notice Get the offer amount for a legendary rarity LTC (Liquid Trading Card)
     * @return The legendary offer amount
     */
    function LEGENDARY_OFFER() external view returns (uint256);

    /**
     * @notice Get the offer amount for a mythic rarity LTC (Liquid Trading Card)
     * @return The mythic offer amount
     */
    function MYTHIC_OFFER() external view returns (uint256);

    /**
     * @notice Get the booster token contract address
     * @return The booster token address
     */
    function boosterTokenAddress() external view returns (address);

    /**
     * @notice Get the entropy address
     */
    function entropyAddress() external view returns (address);

    /**
     * @notice Get the entropy provider
     */
    function entropyProvider() external view returns (address);

    /**
     * @notice Get the entropy fee
     */
    function getEntropyFee() external view returns (uint256);

    /**
     * @notice Get rarity for a token using its batch
     * @param tokenId The token ID to get rarity for
     * @return rarityInfo A Rarity struct with the rarity level (1-5) and random value
     */
    function getTokenRarity(uint256 tokenId) external view returns (Rarity memory rarityInfo);
}

// SPDX-License-Identifier: BUSL-1.1
// Copyright (C) 2025 Beb, Inc. All Rights Reserved
pragma solidity ^0.8.27;

/**
 * @title IBoosterTokenV2
 * @dev Interface for the BoosterTokenV2 contract with graduation mechanism
 */
interface IBoosterTokenV2 {
    // Enum for market type
    enum MarketType {
        BONDING_CURVE,
        UNISWAP_POOL
    }

    // Events
    event OfferMinted(address indexed recipient, uint256 amount);
    event LiquiditySetup(address indexed pool, uint256 ethAmount, uint256 tokenAmount);
    event PositionFeesCollected(uint256 indexed positionId, uint256 amount0, uint256 amount1);
    event TokensPurchased(address indexed buyer, uint256 amount, uint256 ethPaid);
    event TokensSold(address indexed seller, address indexed recipient, uint256 amount, uint256 ethReceived);
    event UniswapPositionConfigured(address positionManager, address swapRouter, uint256 positionId);
    event TokensSold(address indexed from, uint256 amount);
    event MarketGraduated(address indexed nftAddress, address indexed tokenAddress, address indexed pool, uint256 ethAmount, uint256 tokenAmount, uint256 positionId);
    event BoosterTokenFeesDispersed(uint256 ownerFee, uint256 protocolFee, address owner, address protocolFeeRecipient, uint256 referrerFee, uint256 originReferrerFee, address referrer, address originReferrer);
    event BoosterTokenTransfer(address indexed from, address indexed to, uint256 value, uint256 balanceOfFrom, uint256 balanceOfTo, uint256 totalSupply);

    /**
     * @notice Initialize the BoosterTokenV2 contract
     * @param owner The owner of the token contract
     * @param name The name of the token
     * @param symbol The symbol of the token
     * @param dropAddress The address of the LTC (Liquid Trading Card) drop contract
     * @param factoryAddress The address of the factory contract
     * @param uniswapV3Factory The address of the Uniswap V3 factory
     * @param uniswapV3PositionManager The address of the Uniswap V3 position manager
     * @param uniswapV3SwapRouter The address of the Uniswap V3 swap router
     * @param wethAddress The address of WETH
     * @param bondingCurveAddress The address of the bonding curve contract
     * @param protocolFeeRecipient The address of the protocol fee recipient
     */
    function initialize(
        address owner,
        string memory name,
        string memory symbol,
        address dropAddress,
        address factoryAddress,
        address uniswapV3Factory,
        address uniswapV3PositionManager,
        address uniswapV3SwapRouter,
        address wethAddress,
        address bondingCurveAddress,
        address protocolFeeRecipient
    ) external;

    /**
     * @notice Get current market type (BONDING_CURVE or UNISWAP_POOL)
     * @return The current market type
     */
    function marketType() external view returns (MarketType);

    /**
     * @notice Buy tokens with ETH
     * @param tokenAmount Amount of tokens to buy
     * @param recipient Address to receive the tokens
     */
    function buy(uint256 tokenAmount, address recipient) external payable;

    /**
     * @notice Buy tokens with ETH
     * @param tokenAmount Amount of tokens to buy
     * @param recipient Address to receive the tokens
     * @param referrer The address of the referrer
     * @param originReferrer The address of the origin referrer
     */
    function buy(uint256 tokenAmount, address recipient, address referrer, address originReferrer) external payable;

    /**
     * @notice Sell tokens for ETH
     * @param tokensToSell The number of tokens to sell
     * @param recipient The address to receive the ETH payout
     * @param minPayoutSize The minimum ETH payout to prevent slippage
     * @param referrer The address of the referrer
     * @param originReferrer The address of the origin referrer
     */
    function sell(
        uint256 tokensToSell,
        address recipient,
        uint256 minPayoutSize,
        address referrer,
        address originReferrer
    ) external returns (uint256);

    /**
     * @notice Sell tokens for ETH (only available after graduation)
     * @param tokensToSell The number of tokens to sell
     * @param recipient The address to receive the ETH payout
     * @param minPayoutSize The minimum ETH payout to prevent slippage
     * @return Amount of ETH received
     */
    function sell(
        uint256 tokensToSell,
        address recipient,
        uint256 minPayoutSize
    ) external returns (uint256);

    /**
     * @notice Sells tokens from the specified address to the contract
     * @param from The address to sell tokens from
     * @param amount The amount of tokens to sell
     */
    function sellTokens(address from, uint256 amount) external;

    /**
     * @notice Mints tokens as offers for selling LTCs (Liquid Trading Cards)
     * @param recipient The address to receive the tokens
     * @param amount The amount of tokens to mint
     */
    function mintOffer(address recipient, uint256 amount) external;

    /**
     * @notice Get quote for buying tokens with ETH using bonding curve
     * @param ethAmount Amount of ETH to spend
     * @return Token amount that can be purchased
     */
    function getEthBuyQuote(uint256 ethAmount) external view returns (uint256);

    /**
     * @notice Get quote for buying tokens with a specified token amount
     * @param tokenAmount Amount of tokens to purchase
     * @return ETH amount needed
     */
    function getTokenBuyQuote(uint256 tokenAmount) external view returns (uint256);

    /**
     * @notice Get quote for selling tokens for ETH using bonding curve
     * @param tokenAmount Amount of tokens to sell
     * @return ETH amount received
     */
    function getTokenSellQuote(uint256 tokenAmount) external view returns (uint256);

    /**
     * @notice Get the address of the bonding curve contract
     * @return The bonding curve address
     */
    function bondingCurve() external view returns (address);

    function poolAddress() external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.23;

interface IBoosterCardSeedUtils {
    /**
     * @notice Generates a wear value from a seed
     * @param seed The seed value to generate wear from
     * @return wear A string representing the wear value with exactly 10 decimal places
     */
    function wearFromSeed(bytes32 seed) external pure returns (string memory wear);

    /**
     * @notice Gets the foil mapping from a seed
     * @param seed The seed value to determine foil type
     * @return foilType The foil type: "Prize", "Standard", or "Normal"
     */
    function getFoilMappingFromSeed(bytes32 seed) external pure returns (string memory foilType);

    /**
     * @notice Gets both wear and foil data from a seed
     * @param seed The seed value (bytes32(0) returns defaults)
     * @return wear The wear value string
     * @return foilType The foil type string
     */
    function getCardSeedData(bytes32 seed) external pure returns (string memory wear, string memory foilType);
}