BondingCurveToken & CompanyTokenLauncher

/// @notice The factory contract authorized to mint/burn (immutable, set in constructor)
function factory() external view returns (address);
 
/// @notice The ERC-8004 identity hash this token represents
function identityHash() external view returns (bytes32);
 
/// @notice Company ID hash (zero for legacy agent tokens)
function companyId() external view returns (bytes32);
 
/// @notice Market cap threshold for V4 graduation (USDC, 6 decimals)
function graduationThreshold() external view returns (uint256);
 
/// @notice Whether this token has graduated to a V4 pool
function isGraduated() external view returns (bool);
 
/// @notice Mint tokens (factory only, reverts if graduated)
function mint(address to, uint256 amount) external;
 
/// @notice Burn tokens from holder (factory only, no allowance needed, reverts if graduated)
function burnFrom(address from, uint256 amount) external;
 
/// @notice Initialize company-specific fields (factory only, once)
function initializeCompany(bytes32 _companyId, uint256 _graduationThreshold) external;
 
/// @notice Mark token as graduated (factory only)
function graduate() external;

/// @notice Deploy a company token on a bonding curve.
/// @param companyId Unique identifier (keccak256 of company slug)
/// @param name Token name (e.g., "ZeroToOne")
/// @param symbol Token symbol (e.g., "ZTO")
/// @return token The deployed BondingCurveToken address
function launchCompany(
    bytes32 companyId,
    string calldata name,
    string calldata symbol
) external returns (address token);

/// @notice Buy company tokens from the bonding curve using USDC.
/// @param companyId Company identifier
/// @param usdcAmount Amount of USDC to spend (6 decimals)
/// @param minOut Minimum tokens to receive (slippage protection)
/// @return tokensOut Number of tokens received (18 decimals)
function buyFromCurve(
    bytes32 companyId,
    uint256 usdcAmount,
    uint256 minOut
) external returns (uint256 tokensOut);
 
/// @notice Sell company tokens back to the bonding curve for USDC.
/// @param companyId Company identifier
/// @param tokenAmount Amount of tokens to sell (18 decimals)
/// @param minOut Minimum USDC to receive (slippage protection)
/// @return usdcOut Amount of USDC received (6 decimals)
function sellToCurve(
    bytes32 companyId,
    uint256 tokenAmount,
    uint256 minOut
) external returns (uint256 usdcOut);

/// @notice Current token price on the bonding curve.
/// price = reserve * PPM / (supply * CW)
/// @return price USDC per token (6 decimals, scaled to 1e18 token)
function getCurrentPrice(bytes32 companyId) external view returns (uint256);
 
/// @notice Current market cap on the bonding curve.
/// marketCap = reserve * PPM / CW
/// @return marketCap In USDC (6 decimals)
function getCurrentMarketCap(bytes32 companyId) external view returns (uint256);
 
/// @notice Get bonding curve state for a company.
function getBondingState(bytes32 companyId) external view returns (BondingState memory);
 
/// @notice Get the V4 pool record for a graduated company.
function getCompanyPool(bytes32 companyId) external view returns (CompanyPool memory);
 
/// @notice Total number of companies that have launched tokens.
function totalCompanies() external view returns (uint256);

struct BondingState {
    address token;                // BondingCurveToken address
    uint256 reserve;              // USDC reserve balance (6 decimals)
    uint256 graduationThreshold;  // Market cap threshold for V4 graduation
    bool graduated;               // Whether graduated to V4
    uint256 launchedAt;           // Timestamp
}
 
struct CompanyPool {
    address token;
    PoolId poolId;
    uint256 initialSupply;
    uint256 initialPriceUsdc;
    uint256 launchedAt;
}

Buy:  tokensOut = supply * ((1 + usdcAmount / reserve) ^ (CW/PPM) - 1)
Sell: usdcOut   = reserve * (1 - (1 - tokenAmount / supply) ^ (PPM/CW))

Spot price:  price = reserve * PPM / (supply * CW)
Market cap:  marketCap = reserve * PPM / CW

event BondingCurveDeployed(bytes32 indexed companyId, address indexed token, uint256 graduationThreshold);
event TokenBought(bytes32 indexed companyId, address indexed buyer, uint256 usdcIn, uint256 tokensOut);
event TokenSold(bytes32 indexed companyId, address indexed seller, uint256 tokensIn, uint256 usdcOut);
event CompanyGraduated(bytes32 indexed companyId, address token, PoolId poolId, uint256 marketCap);
event PoolInitialized(bytes32 indexed companyId, PoolId indexed poolId, address token, address usdc, uint160 sqrtPriceX96);
event ScoutInvestFailed(bytes32 indexed companyId, address token, bytes reason);