> For the complete documentation index, see [llms.txt](https://canopy-network.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://canopy-network.gitbook.io/docs/app-builder/economics-of-a-chain-launch.md).

# Economics of a Chain Launch

Launching a new app has a classic cold-start problem: you need validators to attract users, users to attract validators, and a community before you can build either. Most projects solve this by seeking grants, incubator backing, or private investment, often before their application exists.

Canopy Terminal offers a different path. When you launch on Canopy, your project and token go live together, letting the community find you from day one. This page explains what that means for your economics as a creator: what you earn, how to structure your token allocation, and what the network looks like once your app is live.

On Canopy, every app is its own blockchain. You don't need to think about these as separate things. Managing the underlying infrastructure is Canopy's job. When you build on Canopy Terminal, you're building an app that is also its own network.

### How the Launch Works

When you launch on Canopy Terminal, your project token becomes available through a bonding curve, an automated pricing mechanism where price adjusts based on supply and demand. Early participants get lower prices. Price increases as more tokens are purchased and decreases when tokens are sold back. The curve is transparent and runs automatically.

Your app moves through this phase building activity and community until it reaches the graduation threshold (currently 50,000 CNPY). At that point, it transitions out of the bonding curve and into a full app with DEX liquidity, staking, and live network support.

### Launch Lifecycle

{% code expandable="true" %}

```mermaid
timeline
    title Canopy Chain Launch Lifecycle
    Coding
        : Builder creates or configures an appchain
        : Core application logic is prepared
    Launch
        : Project launches on Canopy
        : Token becomes available through the bonding curve
   Demand
        : Users buy and sell the project token
        : Creator fees and early market activity help form the treasury

    Graduation
        : Project reaches the required threshold
        : Chain moves into a more mature lifecycle with DEX liquidity and programmable utilit
```

{% endcode %}

### What does the Bonding Curve provide

After launch, the project enters its public sale phase in which users can buy and sell the project token instantly. The goal is to build enough demand, liquidity, and community conviction for the project to graduate.

For builders, the bonding curve phase provides a path that doesn’t require waiting for institutional backing. A project that resonates with the community can attract participants from day one. Creator fees and early market activity generate income for the builder throughout this phase, which can be especially useful for those who need early resources to prove demand, attract contributors, or start the first stage of development.

### What You Earn as a Creator

You don’t need to purchase any of your own project’s tokens to earn from your launch.

Canopy Terminal pays creators 0.5% of every trade on their project token, similar to how platforms like Pump.fun or Virtuals work. These fees accrue from the moment trading begins but are held and distributed at graduation. They are only paid out if your project reaches the graduation threshold, which incentivizes builders to create something with real demand. The size of your personal token holdings has no bearing on this.

#### If you choose to buy in

As the app creator, you have priority access before the public sale opens. You can purchase tokens at the lowest available price, before any other participant. Those tokens are immediately liquid. Buying in early gives you direct exposure to your app’s token price on top of your fee income, though it is entirely optional.

#### After graduation

If your app reaches graduation, you may hold liquid project tokens and participate in staking mechanics that involve both your native token and CNPY. The staking economics are covered in detail below.

### Setting Up a Founder Allocation

A common question from builders: "I want to create a founder's allocation. How do I do that?"

There are two mechanisms, and they can be combined:

1. Buy at launch. As the app creator, you have priority access before the public sale opens. Tokens purchased at launch are immediately liquid and can be held, distributed to team members, or designated as a founder allocation. The amount is entirely up to you, including zero.
2. Use the mint function. Your application’s code can invoke the mint function to reserve token allocations that aren’t pre-purchased. This is application-layer logic: code you write and deploy as part of your project, not a setting in the Canopy Terminal UI.<br>

Using either or both approaches, an app creator can set up separate wallets with distinct allocations for different purposes:

* Founder shares
* Protocol treasury
* Advisor pools
* Grant ecosystems
* Strategic reserves

#### Token controls and lockups

Lockup schedules, release rates, whitelists, blacklists, and burn conditions are all configurable, but they must be built into your application’s code. They live at the app layer, like any other application logic, and are not automatic settings in the Terminal.

A project can technically use aggressive allocation settings, but doing so tends to reduce community trust and makes it harder to attract participants, validators, and contributors. The app creator controls these settings and is responsible for how they are communicated.

### What Graduation Means

Graduation is when your app’s economic foundation becomes real. It is the point where your project transitions from a bonding curve into a functioning app with a full network behind it.

At the graduation threshold (currently 50,000 CNPY), your app exits with:

* A liquid project token (liquidity provided by the built in DEX)
* A defined market cap denominated in CNPY
* A holder base with real participation
* A fully functional app, including an explorer and wallet support

The graduation threshold is subject to change based on Canopy governance. The current requirement is [50,000 CNPY](https://canopy-network.gitbook.io/docs/canopy-network/canopy-economics#distribution).&#x20;

**Of note:** Launch graduation refers to completing the bonding curve phase. This is distinct from sovereignty graduation, where an app may later transition toward Root Chain independence as a Security Root or sovereign app. Launch graduation comes first.

### What You Control After Graduation

Graduating your app means more than reaching a threshold. It means your app now operates with full autonomy over its own network layer.

After graduation, you control your app's governance, fee structures, sequencing, and protocol upgrades. These decisions belong to you, not Canopy. There is no ongoing obligation to the root network once your app has graduated.

You also gain the ability to become a security provider for future apps built on top of yours. Rather than relying on Canopy's security model as a consumer, your app can serve as a root of security for nested apps, participating in the same recursive model that Canopy itself uses.<br>

From an economic standpoint, graduation is also designed so that the creator, founding team and community retain the long-term value generated by the chain. The graduation process ensures the application has proven to have an aligned community, security assurances, and economic demand.&#x20;

Graduation does not cut you off from the broader ecosystem. Your app retains access to the interoperability tools built into the Canopy stack, including cross-app communication and shared infrastructure, without being subject to decisions made at the root level.<br>

### Token Economics After Graduation

Once your app graduates, token holders can stake. This is where economics becomes particularly compelling for early participants.

#### Dual-asset rewards

Staking on a Canopy app earns rewards in two assets simultaneously: your app’s native token and CNPY.

Here’s the mechanism: every time Canopy produces a block, that block production also triggers your app to produce a block, distributing native token rewards to your app’s participants. At the same time, your app’s committee (the validators running your app) earns a share of Canopy’s CNPY block reward. By default, 20% of each CNPY block reward flows to native token stakers, split evenly between validators and delegators.

The result: stakers in your app earn a portfolio of tokens, not just exposure to a single asset.

#### The early-staker opportunity

If someone holds and stakes 10% of an app’s native token supply shortly after graduation, they are eligible for up to 10% of the rewards distributed to native token stakers, paid in both native tokens and CNPY. In the early days of an app, when total staked supply is still small, that share can represent a significant position in network economics.

For context: Canopy’s starting block reward is 80 CNPY per block, with approximately one block every 20 seconds. Block rewards halve every two years. For an active app with committed stakers, an early position can compound meaningfully over time.

#### How rewards are distributed

Your app's committee, which is made up of the validators running your app, controls how rewards are distributed among participants. Most apps use the default protocol configuration, which Canopy applies automatically. The default splits rewards as follows:

* 70% → CNPY staker (block producer)
* 10% → CNPY staker (delegator)
* 10% → Native token staker (validator)
* 10% → Native token staker (delegator)

For full details on Canopy’s reward mechanics, see [Canopy Economics](https://canopy-network.gitbook.io/docs/canopy-network/canopy-economics#distribution). Apps mirror this economic system by default.

### Why Launch on Canopy Terminal?

You earn from day one. Creator fees start accruing the moment trading begins. You don’t need to hold any tokens yourself to earn them.

Your community forms around your project. Instead of waiting for institutional validation, your token goes live and interested participants join the network. The bonding curve creates transparent price discovery and demonstrates real engagement.

You graduate with a working app, not just a whitepaper. Reaching graduation means you exit with a liquid token, a holder base, DEX liquidity, and a fully functional app, complete with explorer and wallet support.

Early participants have real economic exposure. The dual-asset staking model gives token holders a reason to stay engaged after launch: staking earns both native token rewards and CNPY, with early stakers potentially capturing a meaningful share of network rewards.

You control your token economics. Founder allocations, team reserves, lockup schedules, and distribution rules are all configurable at the application layer. You decide how to structure ownership in your network.

### How This Looks in Practice

Example Project: Relay — a decentralized push notification network for on-chain apps.

Say a builder launches Relay on Canopy Terminal and decides to put $50 toward their own project at launch. At a CNPY price of $0.20, that's 250 CNPY.

Using the bonding curve, 250 CNPY at launch yields approximately 14,988,500 RELAY tokens, about 1.89% of the sellable token supply. The entry price is roughly 0.0000169 CNPY per RELAY. No one else can buy before the creator at launch, so this is the lowest price available.

As trading activity builds, two fee pools accrue and are held:

* Creator fee (0.5% of every trade)
* App treasury fee (1% of every trade)

Both are locked until graduation. They are not paid out continuously.

When Relay reaches the graduation threshold (50,000 CNPY), the curve closes. At that point, the graduation price is approximately 0.000242 CNPY per RELAY. The creator's 14,988,500 tokens are now worth about 3,622 CNPY ($724).

Assuming 1,000,000 CNPY in total trading volume across the bonding curve phase, the fee pools pay out at graduation as follows: the creator receives 5,000 CNPY ($1,000) in accumulated creator fees, and the app treasury receives 10,000 CNPY ($2,000).

At graduation, the creator's total: approximately 8,622 CNPY ($1,724) from a 250 CNPY ($50) investment, roughly 34x in CNPY terms.

That's before any post-graduation staking rewards, which begin flowing to native token holders once the app goes live.

<br>


---

# 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://canopy-network.gitbook.io/docs/app-builder/economics-of-a-chain-launch.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.