Más

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

7 min de lecturaVer como Markdown ↗

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:

Shell
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.
  • 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:

Shell
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 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. 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:

Shell
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:

Shell
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.

Shell
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:

Shell
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:

Shell
provider fleet manifest --manifest=fleet-manifest.json

3. Publica el manifiesto desde la hotkey

Shell
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:

Shell
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:

Shell
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.

Shell
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

Shell
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

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).