Events & Indexing

Factory

event LaunchCreated(
    address indexed launch,
    address indexed token,
    address indexed creator,
    LaunchType launchType,     // uint8, not indexed
    address quoteToken,
    string name,
    string symbol,
    string contractURI,
    bytes launchParams
);

event ImplementationRegistered(LaunchType indexed launchType, address implementation);
event LaunchTypeRetiredChanged(LaunchType indexed launchType, bool retired);
event TypeParamsSet(LaunchType indexed launchType, address indexed quoteToken, bytes params);
event QuoteTokenApproved(address indexed quoteToken, bool wrapsNative, uint64 nativeDivisor,
                         uint128 creationFee, uint128 graduationReward);
event QuoteTokenRevoked(address indexed quoteToken);
event LaunchDefaultsUpdated(uint16 curveFeeBps, uint16 curveFeeProtocolBps, uint16 graduationFeeBps,
                            uint16 poolFeeProtocolBps, uint8 graduationPoolType);
event ListerUpdated(address indexed lister);
event FeesSwept(address indexed quoteToken, address indexed to, uint256 amount);
event FeeRecipientUpdated(address indexed feeRecipient);
event CreationPausedChanged(bool paused);

LaunchCreated is your discovery stream. It carries the creator’s launchParams (for type 1, the addresses exempt from the anti-snipe surcharge) but not the launch’s economics: a launch snapshots the factory defaults and its type’s parameters at creation, so one config() call on a type-1 launch turns the log into a priceable curve. contractURI is write-once — no setter, no update event. Pool creation at graduation logs on the DEX factory, not here.

Launch (one stream per clone)

event Trade(
    address indexed trader,
    bool isBuy,
    uint256 quoteAmount,   // the change in the curve's reserve, in quote units
    uint256 tokenAmount,
    uint256 fee,           // includes any anti-snipe surcharge
    uint256 reserve,       // post-trade
    uint256 sold           // post-trade
);

event CurveCompleted(uint256 reserve);

event Graduated(
    address indexed pool, uint256 tokenId, uint256 quoteSeeded, uint256 tokensSeeded, uint128 liquidity
);

event FeesSwept(address indexed to, uint256 amount);

Semantics that are easy to get wrong:

The launch is log.address. There is no token or launch field — one contract, one token, one stream.
trader is asymmetric by design: on a buy it is the recipient (who ends up holding); on a sell it is the seller (whose balance moved). The event follows whose balance in the launched token changed.
quoteAmount is the reserve delta, whichever entry was used. A buyer paid quoteAmount + fee (minus any completion refund); a seller received quoteAmount − fee.
sold is not monotonic — sells decrease it. It is curve state, not cumulative volume.
CurveCompleted and Graduated share a transaction. The buy that fills the curve emits its Trade, then CurveCompleted, and graduates the launch before it returns — the DEX’s PoolCreated and the locker’s Locked land in between, Graduated last. There is no block in which a launch is full but not graduated.
FeesSwept fires inside collectFees(), once per side actually paid — creator or protocol. A side whose transfer fails emits nothing and keeps its balance.

LunyaLaunchToken

event Graduated();   // zero parameters, emitted at graduation

Same name as the launch’s Graduated, different topic0. It is a signal only — the token is freely transferable from its first block. Burns show up as ordinary ERC-20 Transfer events to the zero address.

Locker

event Locked(uint256 indexed tokenId, address indexed token, address indexed creatorFeeRecipient, uint16 protocolBps);
event FeesCollected(uint256 indexed tokenId, address indexed token,
    uint256 creatorAmount0, uint256 creatorAmount1, uint256 protocolAmount0, uint256 protocolAmount1);
event CreatorFeeRecipientUpdated(uint256 indexed tokenId, address indexed recipient);

event FeesUncollected(uint256 indexed tokenId, address indexed token);       // one leg could not be collected
event PayoutDeferred(uint256 indexed tokenId, address indexed token, address indexed to, uint256 amount);
event OwedWithdrawn(uint256 indexed tokenId, address indexed token, address indexed to, uint256 amount);

event FarmingApprovalSet(uint256 indexed tokenId, bool approved);
event EnteredFarming(uint256 indexed tokenId, address indexed virtualPool);
event ExitedFarming(uint256 indexed tokenId);
event ExitedUnpaid(uint256 indexed tokenId);                                   // the exit succeeded, its payout did not
event RewardsCollected(uint256 indexed tokenId, address indexed token, uint256 creatorAmount, uint256 protocolAmount);
event RewardUnclaimed(uint256 indexed tokenId, address indexed token);

All keyed by tokenId; locker.positionOf(token) maps a graduated token to its position. There is no protocol-recipient event on the locker: the protocol’s side follows the factory, so watch the factory’s FeeRecipientUpdated.

Indexer rules of thumb

Never infer state from balances. A launch rejects stray native transfers, and counts none of any stray quote tokens sent to it; reserve() and progress() are the truth.
Two FeesSwept events share a name, not a topic0: the launch’s (to, amount) per side paid by collectFees(), and the factory’s (quoteToken, to, amount) from sweepFees. At graduation, the launch tries to move its protocol fees to the factory — visible only as an ERC-20 Transfer, and absent if the quote token refused it.
One eth_call per launch (config() on type 1) turns the log stream into a priceable curve. Inside the anti-snipe window, buy fees also depend on openedAt() and the buyer’s exemption.
Attribute launches to creator, fees to creatorFeeRecipient — they can differ.
Handle launch types: the same LaunchCreated stream will carry future implementations. Treat a launch’s ABI as a function of its launchType.

Get Started

Exchange

Earn

Bridge

Launchpad

Raise

Points

Developers

Factory

Launch (one stream per clone)

LunyaLaunchToken

Locker

Indexer rules of thumb

​Factory

​Launch (one stream per clone)

​LunyaLaunchToken

​Locker

​Indexer rules of thumb

Factory

Launch (one stream per clone)

LunyaLaunchToken

Locker

Indexer rules of thumb