$YOU Tokenomics

YouCoin is not a company, and it does not have equity or investors. It is a project that has been fully bootstrapped by its founder, Nader Al-Naji, and thus does not have any VC backing or involvement of any kind.

If you're reading this right now, you have the exact same access to this project as the most sophisticated financial players in the world.

Initially, the only way to obtain $YOU is to buy it with USDC or USDT. You can either buy locked tokens before launch, or you can wait to buy unlocked tokens after launch for a higher price.

Pre-launch tokens receive the lowest possible price but are locked for one year with a four-year linear vest thereafter.

Buying tokens after launch gives you unlocked tokens that you can sell anytime, but you pay a higher price than you would have in the presale, and you may have to click-race against other people.

Before launch, you can deposit USDC and submit a bid to buy $YOU. At the moment of launch, aka “the open,” all bids are aggregated and executed together according to a “bonding curve” formula (more on that in a moment). Everyone who submits a bid in the pre-launch phase receives the exact same average price at the open. Let's call this price P_open.

Roughly, P_open doubles every time the amount of USDC bid doubles. For example, if the pre-launch period aggregated $2,000,000 in USDC bids then P_open would be roughly 2x what it would be if it had only aggregated $1,000,000. A full derivation of the P_open formula is included in the appendix for those interested.

Below is a table showing P_open given varying amounts of USDC demand. Note the price roughly doubles every time the demand doubles.

The P_open price determined from the pre-launch phase is then used as the floor price in the post-launch phase, as we'll discuss in the next section. This means that participating in the pre-launch phase gives you a price that is strictly lower than what one can get in the post-launch phase, at the expense of a lockup.

Tokens purchased in the pre-launch phase are locked for one year after the open, and then vest linearly over four years thereafter.

After launch, $YOU is sold for USDC in such a way that the price goes up algorithmically the more buy demand there is (denominated in USDC). The technical term for this is a “two-way xy=k bonding curve” but the main takeaway is that, roughly, the price 4x'es every time the amount of USDC put in doubles (i.e. the price increases quadratically in the “USDC buy demand”). Note that this is much steeper than in the pre-launch phase, which was only linear in the USDC demand. The exact formula for how the post-launch price increases as a function of USDC buy demand is below:

• price(usdc_demand) = (100,000 + usdc_demand)² / (100,000 × 1,000,000,000)

For a concrete example, below is a table of some prices at varying levels of demand, showing the rough quadrupling in price for every doubling in USDC demand (noting that it's not exactly 4x due to the 100,000 term in the quadratic component of the equation above).

Importantly, the price curve in the post-launch phase does not start at $0.001 as shown in the table above but rather it starts at whatever P_open was. So the initial price will be higher depending on how much demand there was in the pre-launch phase.

For example, if there were $10,000,000 in the pre-launch phase, then the starting price would actually be $0.01105 according to the pre-launch table in the previous section, instead of $0.0001 as shown above. This means that everyone purchasing tokens in the post-launch phase gets a price greater than or equal to P_open depending on how early they were able to get into the curve after the open. This is the downside of waiting until after launch. You get unlocked tokens but pay a higher price for them.

In addition, remember that the price goes up as more people buy. So you have to be quick!

On every trade, YouCoin charges a trading fee that is immediately converted to USDC. This is true for all markets, including major tokens like Bitcoin, Ethereum, and Solana. 50% of this fee is allocated to profile owners, while the other 50% is retained by the exchange. We call the half retained by the exchange the “net fees.”

On every trade the net fees are allocated algorithmically to the buy & burn of $YOU tokens. Of these net fees, we allocate a small portion (10%) to algorithmically buy and burn $DESO to support the proliferation of decentralized social media.

As a concrete example, for every $1 billion in trading fees the exchange generates, ~$500 million goes to profile owners, ~$450 million goes to buy and burn $YOU, and ~$50 million goes to buy and burn $DESO.

$YOU has a fixed total supply of 20 billion, of which 1 billion will be initially purchaseable (5%). The remainder is allocated almost entirely to future initiatives, with a small carve-out of maximum 1 billion tokens for market-making (required for third-party exchange listings). There are no team, advisor, or insider allocations, and all future initiatives will allocate tokens with heavy input from the community, as well as a mandatory 30-day notification period. There are also no other emissions or staking rewards or things like that, what you see here is all there is.

The only unlocked tokens initially will be the portion of the initial 1 billion purchased after launch, plus the circulating market-making allocation (up to 1 billion).

• Circulating:
  • Pre-sale & launch: Up to 1 billion
    • Pre-launch tokens are locked for 1 year with vesting. This means a significant percentage of the 1 billion initial float could be locked. Post-launch tokens come out of the same 1 billion tokens.
    • Below is the percentage of pre-launch tokens that would be purchased at varying levels of pre-launch USDC demand. The widget also shows this.

    Total Pre-Launch USDC Demand	Tokens minted	Percent of Initial Allocation
    $0	0	0.00%
    $1,000,000	729,843,788	72.98%
    $2,000,000	800,000,000	80.00%
    $10,000,000	904,875,078	90.49%
    $20,000,000	931,745,142	93.17%
    $100,000,000	968,873,271	96.89%
    $200,000,000	977,887,923	97.79%

  • Market-making: Up to 1 billion
    • Allocated to an in-house market-making strategy to provide liquidity directly after launch as well as on third-party exchanges upon listing
    • This number represents an upper bound. The strategy may only make use of a fraction of this.
• Non-Circulating:
  • Future initiatives: 18 billion
    • No portion of this allocation can be unlocked without 30 days' notice via a public announcement on X and our other social channels. Follow @youcoin_com for all updates.
    • This allocation will generally be guided heavily by input from the community of existing coin-holders and users. Join our Telegram at t.me/youcoin to be a part of the process.
    • This is a significant carve-out to support future initiatives including but not limited to airdrops rewarded on the basis of points-based incentives

A bonding curve is a function that determines a token's price algorithmically based on how much of that token has been bought. Generally, the more buy demand the higher the price, and vice versa. The “xy=k” curve, used by Uniswap, is arguably the most widely-used variant. Two virtual reserves are tracked: x (USDC, in our case) and y ($YOU). Then an invariant x · y = k is chosen, a constant that never changes as trades happen. This is done seemingly arbitrarily but ends up ensuring that we always have price = x / y before and after any trade. If you are curious, you can actually start from wanting price = x / y, which is desirable because it asymptotes to infinity and zero on both sides, and then see how the invariant falls out of the necessary differential equations. A lot of explanations of bonding curves start at x · y = k but this is not ideal. x · y = k was a means to achieving price = x / y rather than the other way around.

At any instant the marginal price of one token is x / y, i.e. the rate at which a very small trade would clear. When a buyer deposits Δx USDC, the reserve grows to x' = x + Δx and, to keep k constant, the token reserve must shrink to y' = k / x'. The buyer receives y − y' tokens. Because each subsequent purchase further reduces y and raises x, the marginal price strictly increases with cumulative buy demand, which means buyers pay more the later they arrive.

We initialize with x₀ = 100,000 USDC and y₀ = 1,000,000,000 tokens, so k = 10¹⁴. The implied opening price with zero demand is x₀ / y₀ = $0.0001. This is the floor that all subsequent prices build on, and it corresponds to a starting market cap of $0.0001 × 1,000,000,000 = $100,000.

In the post-launch phase, buyers move along the curve one trade at a time and pay more the later they arrive. This is fine for steady-state trading but not good for a launch because it incentivizes a click race in the first seconds, and gives a meaningful advantage to bots with latency advantages. The pre-launch phase fixes this by batching every bid submitted before launch and clearing them all at one uniform price, P_open.

The question is: what should P_open be?

We pick P_open such that the average price the batch pays equals the marginal price of the curve after the batch has cleared. In plain terms: the curve advances to some new state (x₁, y₁), and the price implied by that new state is exactly the price every batch participant pays. No one pays more than the curve's marginal price at the close of the batch, no one pays less, everyone gets the same number.

If we instead naively executed the entire aggregated bid against the bonding curve as a single market order, the first dollar in would clear at the floor while the last dollar in would clear at a much higher marginal price, and the batch as a whole would settle at an average well below the curve's new marginal price. That gap is an immediate arbitrage: at the open, anyone could dump their freshly-minted tokens back into the curve for more USDC than they put in. In fact, there would be a race to do so. Batching at P_open eliminates this because the price the curve opens at (price = x1 / y1) is the same price everyone in the batch paid (total bid amount / tokens received).

Two constraints pin down x₁ and y₁. Let B be the total USDC bid in the batch.

• The bonding-curve invariant holds across the batch: x₀ · y₀ = x₁ · y₁.
• Average price equals final marginal price: B / (y₀ − y₁) = x₁ / y₁. The left side is total USDC put in divided by total tokens distributed, i.e. the dollars-per-token everyone pays. The right side is the marginal price at the new curve state.

Cross-multiplying the second equation:

• B · y₁ = (y₀ − y₁) · x₁

Substitute y₁ = x₀ · y₀ / x₁ from the first equation, multiply through by x₁, and the y₀ cancels out:

• B · x₀ · y₀ = (y₀ − x₀ · y₀ / x₁) · x₁²
• B · x₀ · y₀ = y₀ · x₁² − x₀ · y₀ · x₁
• x₁² − x₀ · x₁ − B · x₀ = 0

This is a quadratic in x₁. Taking the positive root:

• x₁ = (x₀ + √(x₀² + 4 · B · x₀)) / 2 = (x₀ + √(x₀ · (x₀ + 4B))) / 2

From x₁ everything else follows:

• y₁ = x₀ · y₀ / x₁
• P_open = x₁ / y₁ = x₁² / (x₀ · y₀)
• Tokens distributed = y₀ − y₁
• Each participant's allocation = (their bid / B) × tokens distributed.

And below we have two sanity-checks:

• B = 0: x₁ = x₀, so P_open = x₀ / y₀ = $0.0001, the floor.
• B ≫ x₀: x₁ ≈ √(B · x₀), so P_open ≈ B · x₀ / (x₀ · y₀) = B / y₀, which is linear in B. This is why the P_open table shows the price roughly doubling every time the aggregate bid doubles: once you are past the initial regime, the relationship between bid and open price is essentially linear.

In a click-race launch, the late buyer pays more than the early buyer, and the very last buyer typically pays a price far above what the very first buyer paid. Here, everyone in the batch pays the same price. And that price is exactly what the curve will quote to the very next buyer who arrives after the open. So the pre-launch batch is a single, uniform clearing event, and from the perspective of any post-launch buyer the curve simply opens at P_open with no prior history to envy.

After the open, the curve operates the way an xy=k curve normally does: each buy advances the reserves and raises the marginal price. If the post-launch starting state is (x₁, y₁) and a buyer puts in Δx USDC, the new marginal price is:

• price(Δx) = (x₁ + Δx)² / (x₀ · y₀)

In the floor case where the pre-launch raised zero USDC, x₁ = x₀ = 100,000, this reduces to the formula shown in the Post-Launch Details section above:

• price(usdc_demand) = (100,000 + usdc_demand)² / (100,000 × 1,000,000,000)

Because price scales with the square of cumulative USDC demand, doubling the demand quadruples the price. That is much steeper than the pre-launch, where the same doubling roughly doubles the price. The batching trick effectively averages the quadratic curve into a linear relationship between aggregate bid and clearing price.