# Einen Top-200-Platz über die Kommandozeile sichern

Mit `btcli` und `provider` registrierst du einen Hotkey auf SN25, veröffentlichst davon dein Flotten-Manifest und bindest deine Geräte daran. Die Top-200-Seite unter ur.io/app/account/top200 führt durch dieselben Schritte. Lies zuerst die Grenzen: Der Burn wird nicht erstattet, und ein gebundenes Gerät verlässt den Pool.

Befehle zuletzt geprüft am `2026-11-17, provider 2026.11.16-1100466640 (register, publish and bind on mainnet)`.

## Bevor du anfängst

Prüfe, ob das Sichern eines Platzes offen ist:

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

Wenn das `False` ausgibt, hör hier auf. Du kannst noch keinen Platz sichern, und der Burn wird nicht erstattet.

Hier fragt dich nichts nach deiner Wiederherstellungsphrase, und kein Schritt sendet einen Schlüssel irgendwohin. Deine Schlüssel bleiben auf deinen Rechnern. Füge eine Wiederherstellungsphrase niemals in eine Website, ein Formular oder einen Chat ein.

## Kenne zuerst die Grenzen

- **Der Burn kostet TAO und wird nicht erstattet.** Er wird von deinem Coldkey bezahlt. Jede Registrierung erhöht ihn um etwa ein Viertel, und er halbiert sich etwa alle 72 Minuten, bis hinunter auf einen Mindestwert von 0,0005 TAO. Prüfe ihn direkt vor dem Bezahlen: `btcli subnets burn-cost 25`. Ist er hoch, warte.
- **Binden kostet Gas.** Etwa 263.640 Gas pro Gerät, also 0,0013 TAO bei 5 Gwei, aus deiner EVM-Wallet.
- **Registriere dich in den 3 Tagen vor der Epoche, in der deine Bindung beginnt.** Eine Bindung beginnt frühestens mit der nächsten 7-tägigen Abrechnungsepoche, und eine UID ohne Emission kann ersetzt werden, sobald ihre Immunität endet, etwa 3 Tage (21.600 Blöcke) nach der Registrierung. Die Top-200-Seite zeigt, wann die nächste Epoche beginnt. Plane Zeit zum Veröffentlichen und Binden ein: Eine Bindung, die nach dem ersten Block dieser Epoche ankommt, muss auf die nächste Epoche warten.
- **Ein volles Subnetz ersetzt jemanden.** SN25 hat 256 UIDs. Jede Registrierung ersetzt die UID, die nicht immun ist und die niedrigste Emission hat, und unter gleichen die älteste Registrierung. Eine UID hat keine Emission, bis ihre Flotte gemessen und ausgewählt ist, oder solange der Validator nicht steuert. Wer zurückkommen will, zahlt den Burn und bindet erneut: siehe [Wenn deine UID ersetzt wird](#if-your-uid-is-replaced).
- **Ein Platz zahlt nur, solange der Validator steuert, und im Verhältnis zu deinem Score, nicht zu deinem Rang.** Alle ausgewählten Flotten teilen sich einen Kanal: 3 % der Miner-Emission vor Epoche 8 und 5 % ab Epoche 8. Eine Flotte mit gesichertem Platz auf Rang 201 oder tiefer verdient nichts aus der Head-Stufe.
- **Binde höchstens 7 Geräte, es sei denn, die übrigen werden bereits gemessen.** Validatoren messen nur Provider in der Verify-Kohorte. Aktive Mitglieder einer Flotte mit gesichertem Platz kommen zuerst hinein, bis zu einem Anteil pro Flotte, und inaktive Mitglieder rücken heraus, um Platz zu machen (`server controller/sn_fleet_binding.go`, `model/verify_cohort_model.go`). Der Anteil ist die Kohortengröße geteilt durch 200 Plätze, also 7 Geräte bei einer Kohorte von 1.500. Ein gebundenes Gerät außerhalb der Kohorte erhält keinen Head-Score und hat den Pool verlassen, verdient also nichts.
- **Gebundene Geräte verlassen den Pool.** Solange die Bindung eines Geräts an einer der beiden Grenzen einer Epoche aktiv ist, erhält es keinen Pool-Anteil, egal ob die Flotte verdient: Seine Zeile ist mit `head_excluded` markiert, und das Register überspringt sie (`sn protocol/ledger_allocation.go`, `server controller/st_head_exclusion.go`). Ein Gerät verdient immer nur in einer Stufe. Coldkeys behalten, was ihre Pool-Konten bereits angesammelt haben.
- **Ein Commitment, das älter als 14 Tage ist, kann keine neuen Geräte binden.** Das sind 100.800 Blöcke. Um später Geräte hinzuzufügen, veröffentliche zuerst erneut. Wenn du schon veröffentlicht hast, musst du eventuell erneut veröffentlichen: Commitments im alten Format werden nicht gespiegelt, und `provider fleet status` fordert dich auf, ein solches neu zu veröffentlichen.
- **Eine Bindung gilt höchstens 12 Epochen.** Binde erneut vor ihrer letzten Epoche.
- **Binde erst, wenn die Top-200-Seite oder die App dein Netzwerk als messbar anzeigt und dich auffordert, deinen Platz zu sichern.**

## Was du brauchst

- Einen Computer mit `btcli` und einen Coldkey mit genug freiem TAO für Burn und Gebühren. `pip install bittensor` gibt dir das aktuelle `btcli`.
- Einen Hotkey für diese Flotte, der nicht dein Coldkey ist.
- `provider` auf einem Gerät der Flotte. Sein Client-Schlüssel liegt unter `~/.urnetwork/.provider.key`.
- Eine EVM-Wallet auf Chain 964 mit etwas TAO für Gas, für den letzten Schritt.
- Das Autoritätsdokument und die Speichererklärung unten.

In den Befehlen ist `<ws_url>` ein Subtensor-Websocket wie `wss://lite.chain.opentensor.ai:443` und `<rpc_url>` ein JSON-RPC für Chain 964 wie `https://lite.chain.opentensor.ai`.

## Das Autoritätsdokument und der dauerhafte Speicher

Im Mainnet verweigern `provider fleet register`, `publish`, `bind`, `status` und `revoke` den Dienst ohne das geprüfte Autoritätsdokument der Flotten-Runtime. Lade es herunter und prüfe seinen 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
```

Der zweite Befehl muss `0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3` ausgeben. Tut er das nicht, hör auf und schreib dem Support. Eine neue Chain-Runtime braucht ein neues Dokument. Der [Vertrag zu Flotten-Autorität und Wiederherstellung](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md) sagt, was es abdeckt.

`register`, `publish`, `bind` und `revoke` brauchen außerdem eine Erklärung des dauerhaften Speichers, der ihre Wiederherstellungsdaten aufbewahrt. Bereite sie allein mit `provider` vor, und zwar auf dem einen Linux- oder macOS-Rechner, der diese Befehle ausführen wird: `provider fleet storage request`, dann `plan` und `apply`, wie es der Abschnitt [Speicher für Mainnet-Schreibvorgänge vorbereiten](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md#preparing-storage-for-mainnet-writes) beschreibt. `apply` gibt `declaration.path` und `declaration.sha256` aus: Das sind die Werte für `--durable-volumes` und `--durable-volumes-sha256`, und der Hash beginnt bereits mit `sha256:`. Verwende für diese Schritte und jeden späteren schreibenden Flottenbefehl dasselbe `URNETWORK_STATE_DIR` (`~/.urnetwork`, wenn du es nicht setzt), und stelle dieses Verzeichnis nie aus einem Backup wieder her.

Halte beides für die folgenden Befehle in deiner Shell bereit. Diese Arrays funktionieren in bash und 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. Einen Hotkey im Subnetz registrieren

Erstelle den Hotkey, falls du noch keinen hast:

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

Prüfe die Kosten und registriere dich dann. btcli fragt nach Wallet und Hotkey und zeigt den Burn, bevor es etwas ausgibt.

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

`btcli`-Versionen benennen ihre Wallet-Flags unterschiedlich, deshalb nennt der Befehl keine.

`provider fleet register` ist der andere Weg zur Registrierung und ein Probelauf, solange du nicht `--apply` angibst. Es braucht eine rohe Seed-Datei deines Coldkeys, also nimm btcli.

## 2. Das Flotten-Manifest erstellen

Auf einem Provider-Gerät, mit Coordinator und Netuid aus `GET /sn/head` (die Top-200-Seite füllt sie aus), der Adresse deines Hotkeys und der Client-ID dieses Geräts:

```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
```

Füge jedes weitere Gerät mit `--member=<client_id>:<client_key>` hinzu. So gibst du ein Manifest und sein Commitment erneut aus:

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

## 3. Das Manifest vom Hotkey aus veröffentlichen

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

`--hotkey_seed_file` ist der rohe 32-Byte-Seed des Hotkeys, in einer Datei, die nur du lesen kannst, und er bleibt auf diesem Rechner. btcli speichert den Hotkey als JSON, schreibe also einmal den rohen Seed daraus, ohne ihn auszugeben:

```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
```

Das liest die Datei deines Hotkeys, nie die deines Coldkeys, und sendet nichts irgendwohin. Gib den Pfad `hotkey.seed` als `--hotkey_seed_file` an.

Der Commitment-Oracle spiegelt dein Commitment danach von selbst auf Chain 964, sobald es final ist. Bis dahin scheitern Bindungen mit `StaleCommitment()`.

## 4. Die Bindung jedes Geräts signieren

Auf jedem Gerät oder dort, wo der Hotkey-Seed liegt, mit dem Gültigkeitsfenster in Epochen. Die erste Epoche muss nach der aktuellen liegen, und eine Bindung umfasst höchstens 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>
```

Es gibt den Binding-Digest, die Signatur des Hotkeys und den Payload zum Einfügen auf der Top-200-Seite aus. Auf dem Handy nimm stattdessen die App: Einnahmen › Top 200 › Flottenbindung signieren (Earnings › Top 200 › Sign fleet binding).

## 5. Die Hotkey-Signatur

Der Payload aus Schritt 4 enthält sie bereits, wenn du `--hotkey_seed_file` angibst. Liegt der Hotkey-Seed auf einem anderen Rechner, führe dort `provider fleet sign` mit `--client_id` des Geräts und `--hotkey_seed_file` aus und füge die ausgegebene `0x`-Signatur auf der Top-200-Seite ein.

**btcli kann diese Signatur nicht erstellen.** Der Hotkey signiert die 32 Bytes des Binding-Digests. `btcli wallet sign --use-hotkey --message` signiert den Text, den du angibst, ein als Hex getippter Digest ist also andere Bytes, und die Signatur wird nicht verifiziert.

## 6. Einreichen

Füge jeden Payload auf der Top-200-Seite unter ur.io/app/account/top200 ein. Sie antwortet mit den Calldata für dieses Gerät. Sende sie von deiner eigenen EVM-Wallet auf Chain 964. URnetwork sendet die Transaktion niemals für dich.

`provider fleet bind` signiert und reicht stattdessen in einem Schritt ein. Es nimmt `--relayer_key_file`, einen EVM-Schlüssel, der das Gas zahlt, und `--dry-run`. Probiere zuerst den Probelauf.

```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[@]}"
```

## Prüfen und rückgängig machen

```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[@]}"
```

## Wenn deine UID ersetzt wird {#if-your-uid-is-replaced}

Die Bindungen deiner Geräte zählen nicht mehr, sobald der Hotkey keine UID hat, und die Geräte verdienen ab der nächsten Epochengrenze wieder im Pool ihres Operators. So sicherst du dir wieder einen Platz:

1. Registriere den Hotkey erneut (Schritt 1). Das ist ein neuer Burn und eine neue UID.
2. Widerrufe die alte Bindung jedes Geräts ab der nächsten Epoche mit `provider fleet revoke`.
3. Erstelle ein neues Manifest mit einer höheren `--generation` (Schritt 2), veröffentliche es (Schritt 3) und signiere und reiche ab dieser Epoche die Bindung jedes Geräts ein (Schritte 4 bis 6).
