# Reclama un puesto del Top 200 desde la línea de comandos

Usa `btcli` y `provider` para registrar una hotkey en SN25, publicar desde ella tu manifiesto de flota y vincular tus dispositivos a ella. La página Top 200 en ur.io/app/account/top200 sigue los mismos pasos. Lee primero los límites: la quema (burn) no es reembolsable, y un dispositivo vinculado sale del pool.

Comandos comprobados por última vez el `2026-11-17, provider 2026.11.16-1100466640 (register, publish and bind on mainnet)`.

## Antes de empezar

Comprueba que el reclamo de puestos está abierto:

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

Si eso imprime `False`, detente aquí. Aún no puedes completar un reclamo, y la quema no es reembolsable.

Nada de esto te pide tu frase de recuperación, y ningún paso envía una clave a ningún sitio. Tus claves se quedan en tus máquinas. Nunca pegues una frase de recuperación en un sitio web, un formulario o un chat.

## Conoce primero los límites

- **La quema cuesta TAO y no es reembolsable.** Se paga desde tu coldkey. Cada registro la sube alrededor de una cuarta parte, y se reduce a la mitad aproximadamente cada 72 minutos, hasta un mínimo de 0,0005 TAO. Compruébala justo antes de pagar: `btcli subnets burn-cost 25`. Si está alta, espera.
- **Vincular cuesta gas.** Unos 263.640 de gas por dispositivo, o 0,0013 TAO a 5 gwei, desde tu billetera EVM.
- **Regístrate en los 3 días anteriores a la época en la que empieza tu vinculación.** Una vinculación empieza como pronto en la siguiente época de liquidación de 7 días, y una UID sin emisión puede ser reemplazada cuando termina su inmunidad, unos 3 días (21.600 bloques) después de registrarse. La página Top 200 muestra cuándo empieza la próxima época. Deja tiempo para publicar y vincular: una vinculación que llega después del primer bloque de esa época tiene que esperar a la siguiente.
- **Una subred llena reemplaza a alguien.** SN25 tiene 256 UID. Cada registro reemplaza a la UID que no es inmune y tiene la emisión más baja, y entre iguales al registro más antiguo. Una UID no tiene emisión hasta que su flota se mide y se selecciona, o mientras el validador no dirige sus pesos. Volver significa pagar la quema y vincular de nuevo: consulta [Si tu UID es reemplazada](#if-your-uid-is-replaced).
- **Un puesto solo paga mientras el validador dirige sus pesos, y en proporción a tu puntuación, no a tu posición.** Todas las flotas seleccionadas comparten un canal: el 3 % de la emisión de mineros antes de la época 8, y el 5 % a partir de la época 8. Una flota con puesto reclamado en la posición 201 o más abajo no gana nada del nivel principal.
- **Vincula 7 dispositivos como máximo, salvo que los demás ya se estén midiendo.** Los validadores solo miden a los proveedores de la cohorte de verificación. Los miembros activos de una flota con puesto reclamado entran primero, hasta una cuota por flota, y los miembros inactivos salen para dejar sitio (`server controller/sn_fleet_binding.go`, `model/verify_cohort_model.go`). La cuota es el tamaño de la cohorte dividido entre 200 puestos, es decir, 7 dispositivos con una cohorte de 1.500. Un dispositivo vinculado fuera de la cohorte no obtiene puntuación principal y ya ha salido del pool, así que no gana nada.
- **Los dispositivos vinculados salen del pool.** Mientras la vinculación de un dispositivo esté activa en cualquiera de los límites de una época, no obtiene parte del pool, gane o no la flota: su fila se marca como `head_excluded`, y el libro mayor la omite (`sn protocol/ledger_allocation.go`, `server controller/st_head_exclusion.go`). Un dispositivo gana en un solo nivel a la vez. Las coldkeys conservan lo que sus cuentas del pool ya acumularon.
- **Un compromiso con más de 14 días no puede vincular dispositivos nuevos.** Son 100.800 bloques. Para añadir dispositivos más adelante, publica de nuevo primero. Si ya publicaste, quizá tengas que publicar de nuevo: los compromisos en el formato antiguo no se reflejan, y `provider fleet status` te pide volver a publicar uno.
- **Una vinculación dura 12 épocas como máximo.** Vincula de nuevo antes de su última época.
- **Vincula solo cuando la página Top 200 o la app muestre tu red como medible y te invite a reclamar.**

## Qué necesitas

- Un ordenador con `btcli` y una coldkey con suficiente TAO libre para la quema y las comisiones. `pip install bittensor` te da el `btcli` actual.
- Una hotkey para esta flota, que no sea tu coldkey.
- `provider` en un dispositivo de la flota. Su clave de cliente está en `~/.urnetwork/.provider.key`.
- Una billetera EVM en la cadena 964 con algo de TAO para gas, para el último paso.
- El documento de autoridad y la declaración de almacenamiento que se describen abajo.

En los comandos, `<ws_url>` es un websocket de Subtensor como `wss://lite.chain.opentensor.ai:443`, y `<rpc_url>` es un JSON-RPC de la cadena 964 como `https://lite.chain.opentensor.ai`.

## El documento de autoridad y el almacenamiento duradero

En mainnet, `provider fleet register`, `publish`, `bind`, `status` y `revoke` se niegan a ejecutarse sin el documento de autoridad revisado del runtime de flota. Descárgalo y comprueba su 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
```

El segundo comando debe imprimir `0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3`. Si no lo hace, detente y escribe a soporte. Un nuevo runtime de la cadena necesita un nuevo documento. El [contrato de autoridad y recuperación de flota](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md) explica lo que cubre.

`register`, `publish`, `bind` y `revoke` también necesitan una declaración del almacenamiento duradero que guarda sus registros de recuperación. Prepárala únicamente con `provider`, en la misma máquina Linux o macOS que ejecutará todos esos comandos: `provider fleet storage request`, después `plan` y `apply`, como describe [Preparar el almacenamiento para escrituras en mainnet](https://github.com/urfoundation/sn/blob/main/miner/FLEET-MAINNET-RUNTIME.md#preparing-storage-for-mainnet-writes). `apply` imprime `declaration.path` y `declaration.sha256`: son los valores de `--durable-volumes` y `--durable-volumes-sha256`, y el hash ya empieza por `sha256:`. Usa el mismo `URNETWORK_STATE_DIR` (`~/.urnetwork` si no lo defines) para estos pasos y para cada escritura posterior de la flota, y nunca restaures ese directorio desde una copia de seguridad.

Ten ambos en tu shell para los comandos siguientes. Estos arrays funcionan en bash y 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. Registra una hotkey en la subred

Crea la hotkey si no tienes una:

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

Comprueba el coste y luego regístrate. btcli pregunta por la billetera y la hotkey, y muestra la quema antes de gastar nada.

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

Las versiones de `btcli` nombran de forma distinta sus flags de billetera, así que el comando no nombra ninguno.

`provider fleet register` es la otra forma de registrarse, y es una prueba en seco salvo que le pases `--apply`. Necesita un archivo con la semilla sin procesar de tu coldkey, así que usa btcli.

## 2. Crea el manifiesto de flota

En un dispositivo proveedor, con el coordinador y el netuid de `GET /sn/head` (la página Top 200 los rellena), la dirección de tu hotkey y el ID de cliente de este dispositivo:

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

Añade cada otro dispositivo con `--member=<client_id>:<client_key>`. Para imprimir de nuevo un manifiesto y su compromiso:

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

## 3. Publica el manifiesto desde la hotkey

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

`--hotkey_seed_file` es la semilla sin procesar de 32 bytes de la hotkey, en un archivo que solo tú puedes leer, y se queda en esta máquina. btcli guarda la hotkey como JSON, así que escribe una vez la semilla sin procesar a partir de él, sin imprimirla:

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

Esto lee el archivo de tu hotkey, nunca el de tu coldkey, y no envía nada a ningún sitio. Usa la ruta `hotkey.seed` como `--hotkey_seed_file`.

Después, el oráculo de compromisos refleja tu compromiso en la cadena 964 por sí solo, cuando es final. Hasta entonces, las vinculaciones se revierten con `StaleCommitment()`.

## 4. Firma la vinculación de cada dispositivo

En cada dispositivo, o donde se guarde la semilla de la hotkey, con la ventana de validez en épocas. La primera época debe ser posterior a la actual, y una vinculación abarca 12 como máximo:

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

Imprime el digest de la vinculación, la firma de la hotkey y el payload que hay que pegar en la página Top 200. En un teléfono, usa la app: Ganancias › Top 200 › Firmar vinculación de flota (Earnings › Top 200 › Sign fleet binding).

## 5. La firma de la hotkey

El payload del paso 4 ya la incluye cuando pasas `--hotkey_seed_file`. Si la semilla de la hotkey está en otra máquina, ejecuta allí `provider fleet sign` con `--client_id` del dispositivo y `--hotkey_seed_file`, y pega la firma `0x` que imprime en la página Top 200.

**btcli no puede hacer esta firma.** La hotkey firma los 32 bytes del digest de la vinculación. `btcli wallet sign --use-hotkey --message` firma el texto que le das, así que un digest escrito en hexadecimal son otros bytes, y la firma no se verifica.

## 6. Envía

Pega cada payload en la página Top 200, en ur.io/app/account/top200. Responde con el calldata de ese dispositivo. Envíalo desde tu propia billetera EVM en la cadena 964. URnetwork nunca envía la transacción por ti.

`provider fleet bind` firma y envía en un solo paso. Acepta `--relayer_key_file`, una clave EVM que paga el gas, y `--dry-run`. Haz primero la prueba en seco.

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

## Comprobar y deshacer

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

## Si tu UID es reemplazada {#if-your-uid-is-replaced}

Las vinculaciones de tus dispositivos dejan de contar en cuanto la hotkey no tiene UID, y los dispositivos vuelven a ganar en el pool de su operador desde el siguiente límite de época. Para reclamar de nuevo:

1. Registra de nuevo la hotkey (paso 1). Es una nueva quema y una nueva UID.
2. Revoca la vinculación antigua de cada dispositivo desde la siguiente época, con `provider fleet revoke`.
3. Crea un manifiesto nuevo con un `--generation` más alto (paso 2), publícalo (paso 3), y firma y envía la vinculación de cada dispositivo desde esa época (pasos 4 a 6).
