# Root Reborn (/docs/guides/root-reborn)

**Root Reborn** (runtime v441) turns the root network from a passive dividend
pipe into a competitive allocation layer. Root stake's yield used to be sold
to TAO mechanically, every block, the moment it arrived. Now it is deployed
into **baskets** — per-validator, escrowed index funds of subnet alpha,
curated by each validator's root weights — and realized only when a staker
claims.

The share unit of a basket is a **beta token**: a stable count that grows
with accruals and shrinks on claim, while its TAO value moves with the
holdings. [Beta tokens](/docs/concepts/beta-tokens) covers the
representation, the owed formula, and the raw-versus-display scale.

This replaces the old per-subnet claimable system and retires
`set_root_claim_type`. The `claim_root(subnets)` call keeps its SCALE
signature for old clients, but `subnets` is ignored and the call claims
fund-level across every validator; prefer
[`claim-root-with-hotkey`](/docs/tx/claim-root-with-hotkey) for a single
validator. Root staking itself is unchanged: moving TAO in and out of root
stake is not a pool swap — no fee, no slippage, no MEV exposure. For the
thesis and live network numbers, see the
[v441 release notes](/releases/v441-upgrade).

## Why it exists [#why-it-exists]

TAO is a productive asset. The chain provides liquidity to its subnets and
takes a share of each one's token emission back — the **root proportion**,
paid in subnet alpha to root (netuid 0) stakers. Before v441 the protocol
sold that alpha for TAO on arrival, which had three structural costs:

* **Constant sell pressure.** Every subnet token absorbed a mechanical,
  price-insensitive sell stream, distorting price discovery.
* **Burned option value.** Ownership in early-stage subnets was converted
  to short-term TAO flow on a schedule nobody chose.
* **Forced realization.** Stakers received a continuous stream of taxable
  events they could not defer.

Off-chain validator "basket" products already reinvested root yield and
outperformed the passive path — proving demand, but as manual, fee-bearing,
non-comparable one-offs. Root Reborn makes the mechanism native,
standardized, and competitive.

## How the fund works [#how-the-fund-works]

Each root validator runs a single fund. Every epoch, its root alpha dividend
on each subnet is sold to TAO once, then redeployed across the subnets in its
**root weights** vector — buying each destination's alpha into the fund.
Root stakers accrue an entitlement to the fund in proportion to their root
stake; a claim pays it out as TAO staked back to root.

* **Holdings are real stake.** Positions are ordinary stake entries held by
  a chain-owned **escrow** account (a pallet sub-account with no private
  key — it cannot act, sign, or be stolen). Because they are real stake on
  the validator, they keep compounding with the validator's own dividends.
* **Entitlement is a fund fraction, never specific alpha.** A staker's claim is a
  fraction of the *whole fund*, not of any particular subnet position. That
  decoupling lets holdings be rebalanced — or converted to TAO when a subnet
  dissolves — without touching anyone's entitlement.
* **NAV is realizable, not spot.** The fund is valued at what selling its
  holdings would actually fetch at current pool depth, net of fees. A thin
  pool cannot inflate book value; deposit pricing and redemption sizing use
  the same quote.
* **Deposits price at NAV.** New dividends enter at the fund's
  pre-deposit value, so existing holders are neither diluted nor gifted, and
  each deposit bears its own swap slippage.
* **Claims are proportional.** A claim redeems the staker's owed fraction of
  every holding pro-rata, preserving fund composition.
* **Default is accumulate-in-place: hold what you earned.** A validator with
  no custom weights still accrues — each subnet's dividend is credited
  straight into the fund's holding on that subnet, with no sell and no
  redeploy. The protocol executes zero trades (no swap fees, no slippage,
  no mechanical sell pressure) on behalf of a validator that expressed no
  preference, so the default basket is the emission-weighted portfolio the
  dividends themselves describe. Setting a weight vector is what turns on
  the sell-and-redeploy engine. Weight netuid 0 to hold a slice as TAO
  instead of subnet alpha. `set_root_weights` requires at least 8 positive
  destinations (softened when fewer networks exist) and caps any single
  destination at the `RootWeightsCap` share of the vector — 1/16 at launch,
  so a curated basket spreads across at least 16 destinations. Netuid 0
  remains a valid destination to keep part of a curated basket in TAO.

Root validators are transparent fund managers: weight vectors are public,
fund NAV and lifetime return are queryable, and the scoreboard is who made
their stakers the most TAO.

## Becoming a root validator [#becoming-a-root-validator]

Admission is **burn-based**: your coldkey pays the root burn price and the
hotkey is registered — no prior stake required. The price is demand-set like
subnet registration: each registration bumps it (\~×1.26) and it decays back
toward the current `MinBurn` floor with a \~72-minute half-life, so
entry costs at least that floor when the network is quiet and more under
registration pressure.

```bash
btcli subnets burn-cost 0                        # current root registration price
btcli subnets register --netuid 0 --dry-run      # preview fee and effects
btcli subnets register --netuid 0 -w my_coldkey -H my_hotkey  # register this hotkey
```

```python
await client.execute(bt.RootRegister(), wallet)
```

Steps to a working fund:

1. **Register** ([`root-register`](/docs/tx/root-register)). The burn is
   recycled out of issuance; registrations are rate-limited per block and per
   root tempo. The hotkey is also auto-childkeyed to every existing subnet
   owner (100% of stake weight on that subnet), unless you opted out with
   `set_auto_parent_delegation_enabled(false)` first. New subnets later do
   the same for every root validator that has not opted out.
2. **Stake your seat.** Root seats are limited (64): when the network is
   full, each new registration prunes the **lowest-staked non-immune**
   member (`ImmunityPeriod`). A seat with no stake behind it earns
   nothing and is the first to be evicted after that window, so
   add root TAO to your own hotkey right away
   (`btcli stake add --netuid 0 --amount ... --hotkey <your hotkey>`). Stake
   also gates weight-setting: the hotkey must clear the minimum stake to
   set weights.
3. **Curate** your basket weights with `btcli root weights` (next section).
   Until you set a vector, dividends accumulate in place — each subnet's
   dividend stays in that subnet's alpha, trade-free.
4. **Earn.** Registration marks the hotkey as a delegate with the default
   18% take; your dividends deploy into the basket each epoch and your
   stakers accrue the rest pro-rata.

Losing the seat is not catastrophic: eviction never touches stake or basket
state, and re-registering only costs the burn again. Stakers keep their
principal and accrued entitlement throughout.

## For validators: curate the basket [#for-validators-curate-the-basket]

Root Reborn launched with `set_root_weights` gated off network-wide, so
every fund began on the null strategy — dividends accumulating in place —
and the network got a clean, uniform baseline before curation opened.
Runtime 449 opened the gate and pinned the concentration cap
(`RootWeightsCap`): no destination may take more than 1/16 of the vector,
so a curated basket spreads across at least 16 destinations. The
`RootWeightSettingDisabled` error now only appears if governance switches
the gate back off.

Curate with your **hotkey** (it must be registered on the root network and
hold the minimum stake to set weights; the root weights rate limit applies).
`btcli root weights` always submits equal weights — every chosen destination
gets exactly 1/N, so on mainnet a set needs at least 16 netuids:

```bash
btcli root weights set --netuids 0,4,8,... -w my_wallet  # replace: equal 1/N across 16+ netuids
btcli root weights add --netuid 23                       # join the set, renormalize to 1/(N+1)
btcli root weights remove --netuid 8                     # drop out, renormalize
btcli root weights show 5F...                            # a validator's non-zero weights
btcli root list 5F...                 # full fund: weights, holdings, NAV, lifetime return
```

```python
intent = bt.SetRootWeights(netuids=[0, 4, 8, ...], weights=[0.2, 0.3, 0.1, ...])
await client.execute(intent, wallet)
```

Uneven vectors are available through the SDK (above) or the raw transaction
command `btcli tx set-root-weights`; the `btcli root weights` porcelain is
deliberately equal-weight. Weights are relative — they are normalized and
quantized to u16 before submission
([`set-root-weights`](/docs/tx/set-root-weights)). Every destination must be
netuid 0 or an existing subnet, and a share above the cap fails with
`RootWeightCapExceeded`. Read a vector back with
[`validator-root-weights`](/docs/query/validator-root-weights); inspect the
fund with [`validator-basket`](/docs/query/validator-basket) and
[`validator-basket-nav`](/docs/query/validator-basket-nav).

## For stakers: accrue and claim [#for-stakers-accrue-and-claim]

Two ways in. `btcli stake add --netuid 0` puts principal on a validator;
dividends then accrue as β. `btcli root allocate` deploys TAO into the
fund now and credits β immediately (you bear entry slippage). `btcli`
presents root positions in TAO: *staked* is your principal on netuid 0,
*accrued* is your β marked at the realizable quote.
`btcli stake list` and `btcli wallet overview` show the accrued basket
yield under the total; auto-claim is off, so realize it with
`btcli root claim`. Per-validator breakdown is `btcli root list --mine`.

```bash
btcli stake list                                  # positions + accrued basket yield
btcli wallet overview                             # same yield line on the wallet view
btcli root list                                   # fund leaderboard: NAV, rate vs index
btcli root list 5F...                             # one fund in detail + your position
btcli root list --mine                            # staked + accrued τ per validator
btcli root allocate --amount 100 --hotkey 5F...  # buy β now
btcli stake remove --netuid 0 --hotkey 5F... --amount 40   # principal only; yield stays owed
btcli stake remove --netuid 0 --hotkey 5F... --amount all --claim  # claim all, then unstake
btcli root claim --dry-run --hotkey 5F...         # reserved vs spent fee, vs accrued
btcli root claim                                  # pick wallet → validator → claim
btcli root claim --hotkey 5F...                   # claim accrued into root stake
```

Unstake (`btcli stake remove --netuid 0`) returns principal. Basket yield
stays owed. After a root unstake, `btcli` tells you if yield is still sitting
there and offers `btcli root claim`. When `RootStakeUnlockInterval` is zero,
pass `--claim` on the unstake to redeem that validator's **whole** entitlement
first, then unstake in one batch. That is not a proportional payout: unstaking
40% still claims 100% of the basket. The chain has no "pay out 40% of the
basket" call. When the interval is nonzero, the atomic form is unavailable
because the claim starts a new hold window. Claim first, wait out the full
interval, then unstake separately.

`btcli root claim` realizes accrued yield into root stake on that validator —
principal is never touched, and there is no partial claim. To withdraw τ to
free balance afterwards, unstake normally with `btcli stake remove --netuid 0`.
Under the hood a claim uses
[`claim-root-with-hotkey`](/docs/tx/claim-root-with-hotkey) (and the unstake
[`remove-stake`](/docs/tx/remove-stake)).

```python
owed = await client.read(
    "root_basket_owed_breakdown",
    coldkey_ss58=wallet.coldkeypub.ss58_address,
)
await client.execute(bt.ClaimRootWithHotkey(hotkey_ss58=validator_hotkey), wallet)
# coldkey-wide (compat): await client.execute(bt.ClaimRoot(subnets=[0]), wallet)
```

[`claim-root-with-hotkey`](/docs/tx/claim-root-with-hotkey) takes the validator
hotkey: it redeems your accrued entitlement on that validator only as a
pro-rata slice of its basket (alpha holdings are sold to TAO at the pool
price), and stakes the proceeds back to root on the same validator.
[`claim-root`](/docs/tx/claim-root) still exists for old clients — it keeps the
pre-basket `subnets` argument (ignored) and walks every validator the coldkey
root-stakes to.

* **Claim threshold.** Per-validator payouts below the network threshold
  (default 500,000 rao = τ0.0005, at most τ0.01; read it with
  [`root-claim-threshold`](/docs/query/root-claim-threshold)) are skipped —
  the entitlement keeps accruing and pays out once it clears. There is no
  deadline and nothing expires.
* **Claim fee.** The inclusion fee scales with how many ALPHA types the
  basket holds. Both root-claim calls reserve a conservative 256-unit work
  envelope at inclusion, independent of how many networks currently exist,
  and refund the unused part after the claim. The amount you actually spend
  follows the holdings scanned and redeemed (around τ0.057 on a full
  128-holding basket).
  `btcli root claim --dry-run` shows reserved versus spent, compares the
  spent fee to accrued yield, warns if the claim loses money, and
  refuses if free TAO cannot cover the reserved amount.
* **Owed is a live quote.** [`root-basket-owed`](/docs/query/root-basket-owed)
  marks your entitlement at current pool prices, so the number moves with the
  market — a claim realizes whatever the pools pay at execution time.
* **Orphaned dust self-consolidates, and fees follow real work.** Any basket
  holding on a subnet the validator's current weight vector no longer points
  at, worth less than the claim threshold, is folded into the fund's root
  (TAO) slot as a side effect of the next claim, deleting the holding.
  Curated positions are exempt — a deliberate small holding keeps compounding
  instead of being flattened to TAO. The transaction fee is charged by what
  the claim actually did: redeemed and consolidated holdings pay full weight,
  holdings merely scanned pay a small per-row cost — so a fund littered with
  stale dust positions gets cheaper to claim after its first claim, not more
  expensive forever.

### What existing root stakers should know [#what-existing-root-stakers-should-know]

* **Nothing to do on upgrade.** Your root stake keeps earning; anything you
  had accrued under the old claim system was migrated into basket
  entitlement on the same validator ([details below](#migrating-from-v437)).
* **Your validator is now a fund manager.** Where your yield goes is their
  root weight vector, and it differs per validator. Inspect it before — and
  while — you delegate: `btcli root list 5F...` shows weights,
  holdings, NAV, and lifetime return. If you disagree with the curation,
  claim out and allocate to a different validator; your principal moves at
  face value.
* **Accrued yield is market-priced.** Until claimed, your entitlement is a
  slice of a fund holding subnet alpha: its TAO quote moves with the pools.
  Principal is unaffected — it stays plain TAO on netuid 0.
* **Claiming compounds, holding defers.** A claim converts entitlement to
  root stake (a realization event); unclaimed entitlement just keeps
  accruing — there is no deadline and nothing expires.
* **Withdrawals can have a hold window.** If the network sets
  `RootStakeUnlockInterval`, root stake is locked for that many blocks after
  your last stake change (anti-sniping around epoch boundaries). A claim also
  refreshes that window, so atomic claim-then-unstake is unavailable whenever
  the interval is nonzero. Claim without withdrawing, wait out the full hold,
  then unstake separately.

## Queries and runtime APIs [#queries-and-runtime-apis]

Every read is available under `btcli query`, the SDK (`client.read(...)`),
and as `betaBasket_*` RPC methods for integrators:

| Read                                                                   | What it returns                                         |
| ---------------------------------------------------------------------- | ------------------------------------------------------- |
| [`root-basket-owed`](/docs/query/root-basket-owed)                     | Total TAO a coldkey would realize by claiming now       |
| [`root-basket-owed-breakdown`](/docs/query/root-basket-owed-breakdown) | The same, itemized per validator hotkey                 |
| [`validator-basket`](/docs/query/validator-basket)                     | A validator's holdings: (netuid, alpha, TAO value) rows |
| [`validator-basket-nav`](/docs/query/validator-basket-nav)             | A validator's fund NAV in TAO                           |
| [`root-basket-total-nav`](/docs/query/root-basket-total-nav)           | Network-wide basket NAV                                 |
| [`validator-root-weights`](/docs/query/validator-root-weights)         | A validator's distribution vector                       |
| [`root-claim-threshold`](/docs/query/root-claim-threshold)             | The minimum per-validator claim payout                  |

## History of `set_root_weights` [#history-of-set_root_weights]

The name is reused; the economic purpose is not.

The historical `set_root_weights` extrinsic was added as an active call in
commit `4fac11ea5` on 2024-04-15, at call index 8. A root validator's
coldkey submitted subnet weights for its hotkey; those weights were
aggregated by root stake and passed through rank/trust/consensus to set the
global emission allocation between subnets. It became a deprecated no-op in
commit `2303a8d07` on 2024-07-18, was renamed to `set_tao_weights` in
`1e2437b9`, and was removed in August 2025 (`d57ebd4a2`).

Root Reborn reintroduced `set_root_weights` in `b3de5f31e` on 2026-06-15
with new arguments and semantics (call index 146): the hotkey publishes a
basket distribution vector for its own fund, not a vote on network-wide
emission.

## Migrating from v437 [#migrating-from-v437]

The per-subnet claim model is retired, and the v441 upgrade migrates all
previously accrued claimable alpha into basket holdings — nothing is lost,
it simply becomes fund entitlement on the same validator.

* `claim_root(subnets)` keeps the same SCALE signature for old clients; the
  `subnets` set is **ignored** and the call claims every validator basket-level.
  Prefer [`claim-root-with-hotkey`](/docs/tx/claim-root-with-hotkey) for a
  single validator.
* `set_root_claim_type` (Swap / Keep / KeepSubnets) is **removed**: payouts
  are always TAO staked back to root. To hold subnet alpha, stake on the
  subnet directly.
* `sudo_set_num_root_claims` is removed; the automatic per-block claim sweep
  is replaced by explicit claims against the fund.
* Hotkey and coldkey swaps carry basket state (holdings, entitlements, watermarks)
  to the new key; subnet dissolution converts that subnet's basket holdings
  into TAO (root stake) inside each fund.