Data & indexing

Every launch, lock, vesting schedule, fee collection, staking action, trade and referral leaves an event on-chain, and a subgraph turns those events into the entities below. This page is the map: what the protocol records, how the entities relate, and — the part that actually bites — how to read the numbers without misinterpreting them.

#Getting at the data

The events are the open source of truth. Every figure on this page is derived from logs any node can serve, and the contracts are written so that nothing needs a follow-up call to reconstruct: the launch event carries a token’s whole configuration, the trade event breaks the fee out from the gross amount, the redemption event carries post-state. Every event signature is on Interfaces. Point your own indexer at them and you get exactly what we have.

#What is indexed

#The shape of the data

These are the queries the app itself runs. Read them as documentation of how the entities join up and which field answers which question — they are the fastest way to see what is available without reading a schema top to bottom.

#Newest launches

{
  tokenLaunches(first: 20, orderBy: createdAt, orderDirection: desc) {
    token { id symbol name decimals }
    creator { id }
    venue                # 1 = Uniswap V3, 5 = SushiSwap V3
    pool
    supply
    creatorBps
    initialMcapEth
    currentMcapEth
    mcapGrowth           # currentMcapEth / initialMcapEth
    bondProgress         # 0..1
    volumeEth
    createdAt
  }
}

#Everything about one launch

query Launch($token: Bytes!) {
  tokenLaunch(id: $token) {
    owner { id }                 # zero address = renounced
    maxWalletBps
    restrictionBlocks
    image description socials
    position { id tokenId creator creatorBps }
    feePolicy        { policyId module venue }   # token side
    creatorFeePolicy { policyId module venue }   # creator side
    poolTxCount poolBuys poolSells
  }
}

#A wallet’s locks and vesting

query Wallet($addr: Bytes!) {
  tokenLocks(where: { owner: $addr }, orderBy: unlockTime) {
    token { symbol decimals } amount unlockTime unlocker withdrawn
  }
  vestingSchedules(where: { beneficiary: $addr }) {
    token { symbol } total released start duration interval
  }
}

#Trade history and referrals

query Trader($addr: Bytes!) {
  trades(where: { user: $addr }, first: 50, orderBy: timestamp, orderDirection: desc) {
    token { symbol } isBuy dex ethAmount tokenAmount fee refFee timestamp tx
  }
  traderPositions(where: { user: $addr }) {
    token { symbol } tokensBought tokensSold ethSpent ethReceived feesPaidEth
  }
  referrer(id: $addr) {
    pendingEth lifetimeEarnedEth claimedEth refereeCount
  }
}

#Reading the numbers correctly

• Everything is ETH-denominated. There is no USD oracle on this chain, so the subgraph stores ETH and USD is applied at display time. Multiply by your own ETH/USD.
• ethAmount on a trade is the gross ETH side — buys include the fee, sells are pre-fee. fee and refFee are broken out so net is derivable.
• ethReceived on a position is net of the platform fee, while ethSpent is gross. Both are “what the user actually experienced”, which is what you want for PnL.
• Amounts are raw base units. Divide by the token’s decimals.
• LaunchHourData buckets only exist for hours that had trades. Sum the last 24 for a 24h volume; do not assume 24 rows.
• BackingVault.lastFloorEth is a snapshot, not the live floor. It is the floor at the last redemption. Redemptions only ever raise it, but a buy in between two of them lowers the real floor — read floorPrice() off the vault for the current number. Likewise accruedWeth tracks the fee stream, not the balance: donations do not add to it and redemptions do not subtract.

#Bonding progress is derived, not stored on-chain

A hood.dev launch has no curve contract, but the launch position is one, so the ETH accumulated inside it is a closed form of the current price. bondedEth is that quantity — a fact. bondTargetEth is a display policy chosen so the number is comparable across tokens, and bondProgress is the ratio.

#Market data

Prices, candles, the trade tape and holder counts in the terminal come from a separate market-data service that aggregates chain-wide indexing and streams over WebSocket. Like the indexer, it is infrastructure for the app rather than a public API — and it is not the source of truth for anything on this page. Protocol state lives in the contracts.

Which is the useful thing to remember: for anything the protocol itself decides — a token’s configuration, its fee policy, who owns it, what is locked, what a vault holds — the contracts are readable by anyone, permanently, with no key and no quota. Nothing on this page is knowledge we can gatekeep; the indexer is a convenience over data that is already yours.