> For the complete documentation index, see [llms.txt](https://hello-fun-1.gitbook.io/hello.fun-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hello-fun-1.gitbook.io/hello.fun-docs/data-and-indexing.md).

# Data & Indexing

Hello.Fun turns onchain activity into readable market data through its indexing infrastructure.

Trades, launches and market activity happen onchain. Hello.Fun reads those events, organizes the information and serves it to the platform so users can follow markets without having to interpret raw blockchain data.

### From Blockchain to Hello.Fun

The data flow begins with activity on Robinhood Chain.

```mermaid
flowchart LR
    A["Robinhood Chain"] --> B["Onchain Events"]
    B --> C["Hello.Fun Indexer"]
    C --> D["PostgreSQL"]
    D --> E["Hello.Fun API"]
    E --> F["Hello.Fun Interface"]
```

The blockchain remains the source of the underlying market activity.

The indexing layer makes that activity usable throughout Hello.Fun.

### The Indexer

The Hello.Fun indexer reads events produced by the launch and trading system.

These events are processed and stored as structured market information.

```mermaid
flowchart TD
    A["Launch Events"] --> E["Indexer"]
    B["Bonding Curve Trades"] --> E
    C["Graduation Activity"] --> E
    D["Uniswap v4 Activity"] --> E
    E --> F["Structured Market Data"]
```

This allows Hello.Fun to maintain a consistent view of a token as it moves through different stages of its lifecycle.

### Market Data

The indexed data supports information including:

1. Price
2. Market capitalization
3. Trading volume
4. Liquidity
5. Holder information
6. Transactions
7. Charts
8. Pair information

This information is derived from actual indexed market activity.

### Price

The source of price information depends on the current stage of the launch.

```mermaid
flowchart TD
    A["Token"] --> B{"Market Stage"}
    B -->|"Before Graduation"| C["Bonding Curve State"]
    B -->|"After Graduation"| D["Uniswap v4 Pool State"]
    C --> E["Displayed Price"]
    D --> E
```

Before graduation, price is derived from the bonding curve market.

After graduation, price is derived from the graduated Uniswap v4 market.

### Market Capitalization

Market capitalization is calculated using the token supply and current price.

Hello.Fun launch tokens have a fixed supply of:

**1,000,000,000 tokens**

```mermaid
flowchart LR
    A["Current Token Price"] --> C["Market Capitalization"]
    B["Token Supply"] --> C
```

As the market price changes, the displayed market capitalization changes with it.

### Trading Volume

Hello.Fun tracks rolling 24 hour trading volume.

The volume calculation follows the token across both stages of its market lifecycle.

```mermaid
flowchart TD
    A["Bonding Curve Trades"] --> C["Indexed Trading Activity"]
    B["Uniswap v4 Swaps"] --> C
    C --> D["Rolling 24 Hour Volume"]
```

This allows trading activity to remain visible after a token graduates from its bonding curve.

### Liquidity

Liquidity information reflects the current market stage.

Before graduation, the launch operates through the bonding curve and its reserves.

After graduation, the market operates through its Uniswap v4 liquidity position.

```mermaid
flowchart LR
    A["Curve Stage"] --> B["Curve Market State"]
    C["Graduated Stage"] --> D["Uniswap v4 Market State"]
```

Hello.Fun indexes the relevant market information for the stage the token is currently in.

### Holders

Holder information is derived from indexed token activity.

This allows Hello.Fun to present holder information alongside other market metrics on token pages and discovery interfaces.

Holder information can also provide context around participation in a token market.

### Transactions

Hello.Fun indexes relevant blockchain events to build transaction activity for its markets.

```mermaid
flowchart LR
    A["Onchain Events"] --> B["Indexer"]
    B --> C["Transaction Data"]
    C --> D["Hello.Fun Token Page"]
```

This gives users a readable view of activity without requiring them to manually interpret raw contract events.

### Charts

Historical indexed activity is used to build market charts.

The chart data follows the token through its market lifecycle.

```mermaid
flowchart LR
    A["Historical Market Activity"] --> B["Indexed Data"]
    B --> C["Chart Data"]
    C --> D["Hello.Fun Interface"]
```

Charts therefore reflect indexed market activity rather than manually entered values.

### Pair Information

Every Hello.Fun market has a pairing asset.

The indexing system tracks the relevant pair information so the interface can identify the market associated with each launch.

ETH is currently the live pairing asset.

As additional supported pairs are introduced, pair information can distinguish markets built around different pairing assets.

### USD Display Values

Hello.Fun can also present market values in USD terms.

ETH to USD pricing is used for display conversion.

```mermaid
flowchart LR
    A["Onchain Market Value"] --> B["ETH Value"]
    B --> C["ETH to USD Feed"]
    C --> D["USD Display Value"]
```

The USD conversion is used for displaying market information.

It does not replace the onchain asset used by the market.

### Database

Indexed information is stored in PostgreSQL.

```mermaid
flowchart LR
    A["Indexer"] --> B["PostgreSQL"]
    B --> C["API"]
    C --> D["Frontend"]
```

This allows Hello.Fun to organize blockchain activity into information that can be searched, filtered and displayed efficiently.

### Read Only API

The Hello.Fun API serves information to the frontend.

Its role is to provide access to indexed data.

It does not execute token launches or trades.

```mermaid
flowchart TD
    A["PostgreSQL"] --> B["Hello.Fun API"]
    B --> C["Frontend"]
    C --> D["User"]

    D --> E["Wallet"]
    E --> F["Smart Contracts"]
```

Reading market information and executing a transaction therefore follow different paths.

The API handles the read path.

The user's wallet and smart contracts handle the transaction path.

### Realtime Updates

Hello.Fun also operates a realtime service for pushing updated information to the interface.

```mermaid
flowchart LR
    A["New Market Activity"] --> B["Indexer"]
    B --> C["Updated Data"]
    C --> D["Realtime Service"]
    D --> E["Hello.Fun Interface"]
```

This allows new activity to appear throughout the platform as markets change.

### Explore and Discovery

Indexed data also powers the discovery experience.

Hello.Fun currently supports:

1. Trending
2. New
3. Search

```mermaid
flowchart TD
    A["Indexed Markets"] --> B["Explore"]
    B --> C["Trending"]
    B --> D["New"]
    B --> E["Search"]
```

The platform can organize launches using real indexed market information rather than relying on manually entered market figures.

### Data Across the Market Lifecycle

One of the important roles of the indexing system is maintaining continuity as a token moves from its bonding curve into Uniswap v4.

```mermaid
flowchart LR
    A["Launch"] --> B["Curve Data"]
    B --> C["Graduation"]
    C --> D["Uniswap v4 Data"]
    D --> E["Continuous Token Market View"]
```

The underlying market changes.

The token page continues to provide a unified view of the launch.

### Data Architecture Summary

```mermaid
flowchart TD
    A["Robinhood Chain"] --> B["Onchain Events"]
    B --> C["Indexer"]
    C --> D["PostgreSQL"]
    D --> E["API"]
    D --> F["Realtime Service"]
    E --> G["Hello.Fun Interface"]
    F --> G
```

The blockchain produces the activity.

The indexer reads it.

The database organizes it.

The API and realtime infrastructure deliver it.

Hello.Fun turns that data into a readable view of each market.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://hello-fun-1.gitbook.io/hello.fun-docs/data-and-indexing.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.