# burned-register (/docs/tx/burned-register)

Pays the subnet's current floating registration cost from the signing
coldkey and assigns the hotkey a UID. When the subnet's collateral lock
share (p) is zero, the full cost is burned/recycled. When p > 0, the
`(1 - p)` share is burned and the `p` share is staked to the hotkey and
locked as miner collateral (released only through earned emission). The
exact TAO charge is only known at execution time, so a configured spend
cap blocks this call until raised. Fails with
`SubNetRegistrationDisabled` while the subnet's `registration_allowed`
toggle is off. On a full subnet, registering evicts the non-immune neuron
with the lowest emission (ties broken by older registration block, then
lower UID), and the new UID can itself be evicted once its immunity
period ends. Use `root_register` instead for the root network
(netuid 0).

| Signer    | Origin                                 | Pallet          | Wraps                                                                                           |
| --------- | -------------------------------------- | --------------- | ----------------------------------------------------------------------------------------------- |
| `coldkey` | signed account (pallet role may apply) | SubtensorModule | [`SubtensorModule.burned_register`](/code/pallets/subtensor/src/macros/dispatches.rs#L816-L824) |

## Parameters [#parameters]

| Parameter     | Type    | Required | Description                                                    |
| ------------- | ------- | -------- | -------------------------------------------------------------- |
| `netuid`      | integer | yes      | Subnet to register on.                                         |
| `hotkey_ss58` | string  | no       | Hotkey that receives the UID; defaults to the wallet's hotkey. |

Address parameters (`--hotkey`, `--coldkey`, `--dest`, ...) accept a raw ss58
address, an address-book or proxy-book name, or a local wallet/hotkey name.

## CLI [#cli]

Preview with `--dry-run` (shows fee, effects, and policy result without
submitting), then submit:

```bash
btcli tx burned-register \
  --netuid <int> --dry-run
btcli tx burned-register \
  --netuid <int> -w my_coldkey
```

## Python [#python]

```python
import bittensor as bt
from bittensor.wallet import Wallet

wallet = Wallet(name="my_coldkey", hotkey="my_hotkey")
intent = bt.BurnedRegister(netuid=1)

sub = bt.Subtensor()
plan = sub.plan(intent, wallet)   # fee, effects, policy — no submission
result = sub.execute(intent, wallet)
if not result.success:
    print(result.error.code, result.error.remediation)
```

(`bt.Subtensor` is also the async client — `async with bt.Subtensor() as client:`
— see [The client](/docs/concepts/client).) Or build the intent by op name, as
an agent would:

```python
result = sub.execute_tool("burned_register", {...}, wallet)
```

## On-chain implementation [#on-chain-implementation]

`SubtensorModule.burned_register` — [`pallets/subtensor/src/macros/dispatches.rs#L818`](/code/pallets/subtensor/src/macros/dispatches.rs#L816-L824):

```rust
#[pallet::call_index(7)]
#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::burned_register())]
pub fn burned_register(
    origin: OriginFor<T>,
    netuid: NetUid,
    hotkey: T::AccountId,
) -> DispatchResult {
    Self::do_register(origin, netuid, hotkey)
}
```

Delegates to [`do_register`](/code/pallets/subtensor/src/subnets/registration.rs#L38).

Every file is browsable under [/code](/code) exactly as built into the runtime, or as plain text under `/code/raw/<path>` (index: [`/code/index.json`](/code/index.json)).