> For the complete documentation index, see [llms.txt](https://stonkmarket.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://stonkmarket.gitbook.io/docs/stonk-v3/fees.md).

# Fees and where they go

Every trade on a stonk token pays a **1% fee, always taken in the backing asset** — never in the token itself. v3 splits that fee four ways instead of three, and the new leg is the interesting one: it never leaves the pool.

## The split

```
someone trades a stonk token
  └─ 1% fee, in the BACKING ASSET (WETH, USDG, …)
       ├─ 10%  →  permanent liquidity   — added to the pool, can never be withdrawn
       ├─ 10%  →  the creator
       ├─ 30%  →  the protocol          — buys and burns $market, and deepens its pool
       └─ 50%  →  treasury
```

Shares are basis points of the **gross** fee and they sum to 10,000. The protocol publishes them as 1000 / 1000 / 3000 / 5000 rather than renormalising to the 9,000 that reaches the locker, because these are numbers people check.

**40% of every fee becomes value nobody can withdraw** — the 10% liquidity leg plus the 30% protocol leg, which ends up as burned $market and as depth in $market's own pool. Treasury's share has a floor of 500 bps that no configuration change can go below.

## The leg that can't be withdrawn

The 10% liquidity share is taken by the **hook**, at the moment the fee is withheld, and it is never an ERC-20 at any point in its life. It sits as an internal Uniswap v4 claim until the hook places it into the pool as a resting bid below the current price.

The guarantee is worth stating precisely:

> Liquidity in a stonk pool can only ever **increase**. No liquidity, from any source, by any caller, ever leaves.

There is no admin function, no creator function, and no emergency path that removes it. A request to remove liquidity is rejected for *every* caller, including the factory. That is why third parties are also blocked from *adding* — with removal banned, an outside LP would be permanently donating their capital, which is a trap rather than a feature.

Deepening happens automatically, as a side effect of an ordinary trade, once the bucket crosses a per-asset threshold. Nobody calls anything.

## $market

$market is the protocol's own token. It is funded by the 30% protocol leg of every other token's fees, and that money does two things: **buys $market and burns it**, and **deepens $market's own pool**. The mix is a dial, so it can be retuned for the whole fleet at once rather than being frozen into each token at launch.

$market trades at **3%**, not 1%, and splits its own fee differently: 25% to its pool as permanent liquidity, 25% to buy-and-burn, 50% to treasury. No creator share — there is no creator.

It is live on Robinhood Chain at [`0x024c1F42e1aD70f2182F2f9BC491823bc4e3d90a`](/docs/stonk-v3/deployments-mainnet.md#market-and-its-sinks), paired with USDG. On chain it reads `symbol` **market** and `name` **stonk** — the ticker is **$market**; the contracts around it keep the Stonk prefix (`StonkBuyback`, `StonkFeeRouter`, `StonkLiquidityRouter`), which is a code name, not the token's.

### A consequence worth knowing

In v3, **$market is gated on the NYSE window like every other token.** In earlier drafts it wasn't — it traded around the clock while every token whose fees funded it did not, which made it the one asset on the platform that wasn't what the platform sells.

The practical effect: **harvesting, converting and burning only work while the market is open.** Fee *accrual* is unaffected — fees pile up overnight exactly as you'd expect — but the calls that convert them revert outside the session. If you're running a keeper, it needs to know the NYSE calendar.

## What you have to call

Nothing, ever, to stay safe. Unclaimed fees sit in the contract that holds them until somebody moves them along, and **every one of these calls is permissionless** — it pays the beneficiary, not the caller.

| Step                    | Who can call                   | When                                                             |
| ----------------------- | ------------------------------ | ---------------------------------------------------------------- |
| Fee withheld and split  | nobody — it's part of the swap | every trade                                                      |
| Liquidity deepens       | nobody — the hook does it      | once the bucket clears its threshold                             |
| `distributeFees(token)` | anyone                         | whenever; moves fees to the locker                               |
| `claimFor(asset, who)`  | anyone                         | pays that beneficiary what they're owed                          |
| `convert(asset)`        | anyone                         | turns a foreign asset's protocol share into $market's pair asset |
| `execute()`             | anyone                         | buys $market and burns it, on an hourly drip                     |

The buyback pays its caller a small share for the gas, which is why it runs without anyone being paid to babysit it.

{% hint style="info" %}
The buyback's clock is **not started** on either live deployment — mainnet included. `start()` arms the drip, and starting it before $market's pool is deep enough to buy into would make the first slice claim every second since deployment. Fees still accrue in the meantime; nothing is lost by waiting.
{% endhint %}


---

# 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://stonkmarket.gitbook.io/docs/stonk-v3/fees.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.