# Claim a Top 200 spot from the command line

Use `btcli` and `provider` to register a hotkey on SN25, publish your fleet manifest from it, and bind your devices to it. The Top 200 page at ur.io/app/account/top200 takes the same steps. Read the limits first: the burn isn't refundable, and a bound device leaves the pool.

Commands last checked on `2026-11-17, provider 2026.11.16-1100466640 (register, publish and bind on mainnet)`.

## Before you start

Check that claiming is open:

```sh
curl -s https://api.bringyour.com/sn/top | python3 -c 'import json,sys; print(json.load(sys.stdin)["snapshot"]["binding_open"])'
```

If that prints `False`, stop here. You can't complete a claim yet, and the burn isn't refundable.

Nothing here asks for your recovery phrase, and no step sends a key anywhere. Your keys stay on your machines. Never paste a recovery phrase into a website, a form or a chat.

## Know the limits first

- **The burn costs TAO and isn't refundable.** It's paid from your coldkey. Each registration raises it by about a quarter, and it halves about every 72 minutes, down to a floor of 0.0005 TAO. Check it right before you pay: `btcli subnets burn-cost 25`. If it's high, wait.
- **Binding costs gas.** About 263,640 gas per device, or 0.0013 TAO at 5 gwei, from your EVM wallet.
- **Register in the 3 days before the epoch your binding starts.** A binding starts no earlier than the next 7-day settlement epoch, and a UID with no emission can be replaced once its immunity ends, about 3 days (21,600 blocks) after it registers. The Top 200 page shows when the next epoch starts. Leave time to publish and bind: a binding that lands after that epoch's first block has to wait for the next epoch.
- **A full subnet replaces someone.** SN25 has 256 UIDs. Each registration replaces the UID that isn't immune and has the lowest emission, and among equals the oldest registration. A UID has no emission until its fleet is measured and selected, or while the validator isn't steering. Coming back means paying the burn and binding again: see [If your UID is replaced](#if-your-uid-is-replaced).
- **A spot pays only while the validator steers, and in proportion to your score, not your rank.** All selected fleets share one channel: 3% of miner emission until epoch 8, and 5% from epoch 8. A claimed fleet ranked 201 or lower earns nothing from the head tier.
- **Bind at most 7 devices, unless the others are already measured.** Validators only measure providers in the verify cohort. Live members of a claimed fleet draw into it first, up to a per-fleet share, and stale members rotate out to make room (`server controller/sn_fleet_binding.go`, `model/verify_cohort_model.go`). The share is the cohort size divided by 200 seats, which is 7 devices at a 1,500 cohort. A bound device outside the cohort earns no head score and has left the pool, so it earns nothing.
- **Bound devices leave the pool.** While a device's binding is active at either boundary of an epoch, it earns no pool share, whether or not the fleet is earning: its row is flagged `head_excluded`, and the ledger skips it (`sn protocol/ledger_allocation.go`, `server controller/st_head_exclusion.go`). A device earns in one tier at a time. Coldkeys keep what their pool accounts already accrued.
- **A commitment older than 14 days can't bind new devices.** That's 100,800 blocks. To add devices later, publish again first. If you published before, you may need to publish again: commitments in the old format aren't mirrored, and `provider fleet status` tells you to republish one.
- **A binding lasts at most 12 epochs.** Bind again before its last epoch.
- **Bind only when the Top 200 page or app shows your network as measurable and prompts you to claim.**

## What you need

- A computer with `btcli` and a coldkey holding enough free TAO for the burn and fees. `pip install bittensor` gives you the current `btcli`.
- A hotkey for this fleet, which is not your coldkey.
- `provider` on a device of the fleet. Its client key is at `~/.urnetwork/.provider.key`.
- An EVM wallet on chain 964 with a little TAO for gas, for the last step.
- The authority document and the storage declaration below.

In the commands, `<ws_url>` is a Subtensor websocket such as `wss://lite.chain.opentensor.ai:443`, and `<rpc_url>` is a chain 964 JSON-RPC such as `https://lite.chain.opentensor.ai`.

## The authority document and durable storage

On mainnet, `provider fleet register`, `publish`, `bind`, `status` and `revoke` refuse to run without the reviewed fleet runtime authority document. Download it and check its hash:

```sh
curl -fsSL -o fleet-runtime-authority.json https://raw.githubusercontent.com/urfoundation/sn/main/mainnet/fleet-runtime-authority/runtime-491.json
shasum -a 256 fleet-runtime-authority.json
```

The second command must print `0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3`. If it doesn't, stop and write to support. A new chain runtime needs a new document. The [fleet authority and recovery contract](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md) says what it covers.

`register`, `publish`, `bind` and `revoke` also need a declaration of the durable storage that keeps their recovery records. Prepare it with `provider` alone, on the one Linux or macOS machine that will run them: `provider fleet storage request`, then `plan` and `apply`, as [Preparing storage for mainnet writes](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md#preparing-storage-for-mainnet-writes) describes. `apply` prints `declaration.path` and `declaration.sha256`: they're the values of `--durable-volumes` and `--durable-volumes-sha256`, and the hash already starts with `sha256:`. Use the same `URNETWORK_STATE_DIR` (`~/.urnetwork` unless you set it) for these steps and every later fleet write, and never restore that directory from a backup.

Keep both in your shell for the commands below. These arrays work in bash and zsh:

```sh
AUTHORITY=(--mainnet-runtime-authority="$PWD/fleet-runtime-authority.json" --mainnet-runtime-authority-sha256=0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3)
DURABLE=(--durable-volumes=<declaration_path> --durable-volumes-sha256=<declaration_sha256>)
```

## 1. Register a hotkey on the subnet

Make the hotkey if you don't have one:

```sh
btcli wallet new-hotkey
```

Check the cost, then register. btcli asks for the wallet and hotkey, and shows the burn before it spends anything.

```sh
btcli subnets burn-cost 25
btcli subnets register --netuid 25
```

`btcli` versions name their wallet flags differently, so the command names none.

`provider fleet register` is the other way to register, and it's a dry run unless given `--apply`. It needs a raw seed file for your coldkey, so use btcli.

## 2. Write the fleet manifest

On a provider device, with the coordinator and netuid from `GET /sn/head` (the Top 200 page fills them in), your hotkey's address and this device's client id:

```sh
provider fleet init --chain_id=964 --coordinator=<0xcoordinator> --netuid=25 --hotkey=<hotkey ss58> --client_seed_file=$HOME/.urnetwork/.provider.key --client_id=<client_id> | head -n 1 > fleet-manifest.json
```

Add each other device with `--member=<client_id>:<client_key>`. To print a manifest and its commitment again:

```sh
provider fleet manifest --manifest=fleet-manifest.json
```

## 3. Publish the manifest from the hotkey

```sh
provider fleet publish --manifest=fleet-manifest.json --substrate=<ws_url> --hotkey_seed_file=<path> "${AUTHORITY[@]}" "${DURABLE[@]}"
```

`--hotkey_seed_file` is the hotkey's raw 32-byte seed, in a file only you can read, and it stays on this machine. btcli keeps the hotkey as JSON, so write the raw seed from it once, without printing it:

```sh
python3 -c 'import json,os,sys; d=json.load(open(sys.argv[1])); fd=os.open(sys.argv[2], os.O_WRONLY|os.O_CREAT|os.O_EXCL, 0o600); os.write(fd, bytes.fromhex(d["secretSeed"][2:])); os.close(fd)' "$HOME/.bittensor/wallets/<wallet>/hotkeys/<hotkey>" hotkey.seed
```

This reads your hotkey's file, never your coldkey's, and sends nothing anywhere. Use the path `hotkey.seed` as `--hotkey_seed_file`.

The commitment oracle then mirrors your commitment to chain 964 by itself, once it's final. Bindings revert with `StaleCommitment()` until it has.

## 4. Sign each device's binding

On each device, or where the hotkey seed is kept, with the validity window in epochs. The first epoch must be later than the current one, and a binding spans at most 12:

```sh
provider fleet sign --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --hotkey_seed_file=<path> --valid_from_epoch=<first epoch> --valid_to_epoch=<last epoch>
```

It prints the binding digest, the hotkey's signature, and the payload to paste on the Top 200 page. On a phone, use the app instead: Earnings › Top 200 › Sign fleet binding.

## 5. The hotkey signature

The payload from step 4 already carries it when you pass `--hotkey_seed_file`. If the hotkey seed is on another machine, run `provider fleet sign` there with the device's `--client_id` and `--hotkey_seed_file`, and paste the `0x` signature it prints on the Top 200 page.

**btcli can't make this signature.** The hotkey signs the 32 bytes of the binding digest. `btcli wallet sign --use-hotkey --message` signs the text you give it, so a digest typed as hex is different bytes, and the signature won't verify.

## 6. Submit

Paste each payload on the Top 200 page, at ur.io/app/account/top200. It answers with the calldata for that device. Send that from your own EVM wallet on chain 964. URnetwork never sends the transaction for you.

`provider fleet bind` signs and submits in one step instead. It takes `--relayer_key_file`, an EVM key that pays the gas, and `--dry-run`. Try the dry run first.

```sh
provider fleet bind --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --hotkey_seed_file=<path> --valid_from_epoch=<first epoch> --valid_to_epoch=<last epoch> --rpc=<rpc_url> --relayer_key_file=<path> --dry-run "${AUTHORITY[@]}" "${DURABLE[@]}"
```

## Check and undo

```sh
provider fleet status --manifest=fleet-manifest.json --client_id=<client_id> --substrate=<ws_url> --rpc=<rpc_url> "${AUTHORITY[@]}"
provider fleet revoke --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --effective_epoch=<epoch> --rpc=<rpc_url> --relayer_key_file=<path> --dry-run "${AUTHORITY[@]}" "${DURABLE[@]}"
```

## If your UID is replaced {#if-your-uid-is-replaced}

Your devices' bindings stop counting once the hotkey has no UID, and the devices go back to earning in their operator's pool from the next epoch boundary. To claim again:

1. Register the hotkey again (step 1). That's a new burn and a new UID.
2. Revoke each device's old binding from the next epoch, with `provider fleet revoke`.
3. Write a new manifest with a higher `--generation` (step 2), publish it (step 3), and sign and submit each device's binding from that epoch (steps 4 to 6).
