> 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/bonding-curve/price-and-slippage.md).

# Price and Slippage

Prices on the Hello.Fun bonding curve change as users buy and sell.

Because each trade changes the state of the market, the price available when a trade is quoted may differ from the price available when that transaction is executed.

Hello.Fun uses trade quotes, price impact information and minimum output protection to help users understand and control this movement.

### How Price Changes

Before graduation, the token price is determined by the current state of its bonding curve.

As tokens are purchased, the price moves upward along the curve.

Selling moves the market in the opposite direction.

```mermaid
flowchart LR
    A["Buy Activity"] --> B["Bonding Curve Changes"]
    B --> C["Token Price Changes"]
    D["Sell Activity"] --> B
```

The price is therefore not manually set after launch.

It develops through the bonding curve as users trade.

### Trade Quotes

Before submitting a buy or sell, Hello.Fun calculates a quote based on the current market state.

A quote provides an expected output for the trade.

```mermaid
flowchart LR
    A["Trade Amount"] --> B["Current Bonding Curve State"]
    B --> C["Quote"]
    C --> D["Expected Output"]
```

A quote represents the market at the time it is calculated.

It does not guarantee that the market will remain unchanged while the user reviews and submits the transaction.

### What Is Slippage?

Slippage is the difference between the expected result of a trade and the result available when the transaction executes.

This can happen when the market changes between the time a quote is calculated and the time the transaction reaches the blockchain.

Hello.Fun allows users to set a slippage tolerance for their trade.

### Minimum Output Protection

Slippage protection is enforced through a minimum acceptable output.

When the trade is submitted, the transaction includes the minimum amount the user is willing to receive.

```mermaid
flowchart TD
    A["Expected Output"] --> B["Slippage Tolerance"]
    B --> C["Minimum Output"]
    C --> D["Transaction Executes"]
    D --> E{"Output Meets Minimum?"}
    E -->|Yes| F["Trade Completes"]
    E -->|No| G["Transaction Reverts"]
```

If the trade cannot meet the minimum output, it does not complete at the less favorable result.

Instead, the transaction reverts.

### What Is Price Impact?

Price impact is the effect a trade itself has on the market price.

This is different from slippage.

A trade can move the bonding curve because it changes the current market state.

The larger the trade relative to the market, the greater its potential price impact.

### Slippage and Price Impact

Although they are related, slippage and price impact describe different things.

| Term           | Meaning                                                                                         |
| -------------- | ----------------------------------------------------------------------------------------------- |
| Price Impact   | The effect the trade itself has on the market price                                             |
| Slippage       | The difference between the quoted result and the result available when the transaction executes |
| Minimum Output | The lowest output the user has agreed to accept                                                 |

Understanding the difference helps users evaluate a trade before signing it.

### Example

Suppose a user requests a quote to buy a token.

Hello.Fun calculates the expected token output from the current bonding curve state.

Before the transaction executes, another trade changes the market.

The available output may now be different.

If the new output remains above the user's minimum accepted amount, the transaction can complete.

If it falls below that amount, the transaction reverts.

```mermaid
flowchart TD
    A["Quote Received"] --> B["Market Changes"]
    B --> C["New Execution Result"]
    C --> D{"Within Slippage Tolerance?"}
    D -->|Yes| E["Trade Completes"]
    D -->|No| F["Trade Reverts"]
```

### After Graduation

Price protection does not disappear when a token graduates.

After graduation, normal trading moves to the token's Uniswap v4 market.

Hello.Fun obtains the post graduation quote through the Uniswap v4 market and continues to use minimum output protection when the trade is submitted.

```mermaid
flowchart LR
    A["Before Graduation"] --> B["Bonding Curve Quote"]
    C["After Graduation"] --> D["Uniswap v4 Quote"]
    B --> E["Minimum Output Protection"]
    D --> E
```

The source of the quote changes.

The user's protection against receiving less than the accepted minimum remains.

### Before Confirming a Trade

Users should review the trade information before signing a transaction.

This includes:

1. Expected output
2. Slippage tolerance
3. Minimum output
4. Price impact
5. Trading fees
6. Network gas

Markets can move between quote and execution.

Slippage protection defines how much movement the user is willing to accept before the transaction should revert.


---

# 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/bonding-curve/price-and-slippage.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.
