1. Ejecutar el nodo de lectura

El paso 1 instala un nodo de lectura de Snapchain en el host de node.env, espera hasta que se haya puesto al día con la red y abre un túnel SSH para que http://127.0.0.1:3381 en tu máquina llegue a la API HTTP del nodo.

./scripts/1-node.sh

Qué hace en el host

Espera hasta que el host responde por SSH. Un servidor nuevo necesita arrancar y ejecutar cloud-init primero; el script lo intenta 60 veces, con 5 segundos de separación.
Espera a que cloud-init termine, si el host lo usa.

Comprueba el host e imprime una fila por comprobación:

Comprobación	Necesita
`ram`	15 GiB (Snapchain pide 16 GB; el kernel se queda con algo)
`disk`	1,8 TiB libres en el directorio de datos, se omite una vez que existe `~/snapchain/.rocks`
`docker`	un servidor Docker con el que el usuario SSH pueda comunicarse
`compose`	Docker Compose 2.24.4 o más reciente, que necesita el override de abajo
`ports`	3381 a 3383 libres; se muestra, nunca falla, ya que en una nueva ejecución el nodo los ocupa
`clock`	a menos de 60 segundos del reloj de tu máquina

Un no en cualquier fila detiene la ejecución con el código de salida 5.

Escribe ~/snapchain/.env con AGREE_NO_REWARDS_FOR_ME=true, HUB_OPERATOR_FID (tu --fid, 0 por defecto), SKIP_CRONTAB=true salvo que pases --autoupgrade, una única contraseña aleatoria de Grafana como GRAFANA_CREDS (que lee el propio script de Snapchain) y GRAFANA_PASSWORD (que el override da a Grafana), y STATSD_PUBLISH y STATSD_ADMIN_PUBLISH apuntando al loopback del host, donde el archivo compose publica statsd. Solo añade claves que el archivo todavía no tiene, y nunca cambia un valor que ya está ahí.
Descarga docker-compose.mainnet.yml (guardado como docker-compose.yml), validators.toml, el grafana.ini de Grafana y el dashboard de Snapchain desde el repositorio de Snapchain en la etiqueta @latest, o en v<version> con --release.
Escribe docker-compose.override.yml, que Docker Compose fusiona sobre el archivo descargado y que las actualizaciones de Snapchain nunca reemplazan. Publica Grafana solo en el loopback del host, le da la contraseña de .env y su fuente de datos y su dashboard y, con --block-retention, configura la poda de bloques.
Arranca los servicios snapchain y statsd con docker compose up -d.
Espera a la sincronización, hasta --timeout segundos (12 horas por defecto).
Abre el túnel, salvo que pases --no-tunnel.

Los pasos 4 a 7 son las partes no interactivas del propio snapchain.sh upgrade de Snapchain; la guía del nodo describe las claves de .env y el archivo override.

Esperar a la sincronización

El primer arranque descarga una instantánea de varios cientos de GB y luego sincroniza los bloques posteriores a esa instantánea. Cuenta con horas. El script imprime el estado completo una vez:

snapchain <version>, synced: no
shard 0  height <n>  behind <s>s  size <x> GiB  mempool n/a
shard 1  height <n>  behind <s>s  size <x> GiB  mempool n/a
shard 2  height <n>  behind <s>s  size <x> GiB  mempool n/a

y luego una línea por comprobación, con la hora, cuánto va retrasado el shard más lento y una estimación a partir del ritmo desde la primera comprobación:

<HH:MM>  <hours>h <minutes>m behind, ETA <estimate>

Las comprobaciones empiezan con 10 segundos de separación y se espacian hasta una por minuto. El nodo cuenta como sincronizado cuando cada shard va menos de 10 segundos retrasado; entonces se imprime de nuevo el estado completo. behind es el blockDelay que el nodo informa en /v1/info. Los nodos de lectura no informan el tamaño del mempool para algunos shards, lo que se muestra como n/a.

Pulsar Ctrl-C termina solo la espera. El nodo sigue sincronizando en el host; ./scripts/1-node.sh status --wait lo vigila desde donde está. Ejecutar ./scripts/1-node.sh de nuevo también funciona, pero repite cada paso y vuelve a descargar el archivo compose (el de la última versión salvo que pases el mismo --release).

El túnel

./scripts/1-node.sh tunnel          # forward 127.0.0.1:3381 and :3383 to the node
./scripts/1-node.sh tunnel --stop   # close it

El túnel es un proceso ssh -N en segundo plano, que se encuentra y se detiene a través de su socket de control en ~/.ssh. No vuelve por sí solo después de que la conexión se cae o tu máquina se reinicia: ejecuta tunnel de nuevo. Si otra cosa ya escucha en el puerto local 3381 o 3383, el túnel no se levanta y el script lo indica.

Otros comandos

Comando	Qué hace
`status`	el estado de sincronización una vez; código de salida 0 cuando está sincronizado, 1 en otro caso
`status --wait`	consulta hasta que está sincronizado, como hace `up`
`logs`	sigue los logs del contenedor `snapchain`; `logs casty` los de la página
`upgrade`	obtiene el archivo compose de la última versión, o el de `--release`, luego descarga la imagen y reinicia
`serve`	ejecuta casty en el host detrás de HTTPS, con `--domain` o `--tailscale`: Desde cualquier red
`down`	detiene el nodo, y casty si está sirviendo; la base de datos se queda en el volumen

status pregunta al nodo por SSH, así que el puerto 3381 nunca tiene que ser público para ello.

Fijar una versión y actualizaciones

El archivo compose de cada versión de Snapchain nombra la imagen farcasterxyz/snapchain:latest. --release 0.14.3 descarga los archivos de v0.14.3 y reescribe esa línea como farcasterxyz/snapchain:0.14.3; si el archivo ya no nombra :latest, el script se detiene en lugar de ejecutar otra cosa. ./scripts/1-node.sh upgrade sin --release vuelve a la última versión.

--autoupgrade --fid <fid> instala en su lugar la tarea semanal de actualización de snapchain.sh, en un día de la semana derivado de tu fid de la misma forma en que lo deriva snapchain.sh. Esa tarea ejecuta docker system prune --volumes -f, que afecta a todos los proyectos Docker del host, no solo a Snapchain. --release y --autoupgrade no se pueden combinar, y --release elimina una tarea de actualización que encuentre, ya que la tarea reemplazaría la versión fijada.

Retención de bloques

--block-retention <n> define SNAPCHAIN_PRUNING__BLOCK_RETENTION para que el nodo pode los bloques de más de n días. Snapchain lo permite solo en nodos de lectura y lo deja desactivado por defecto. El valor es una duración, que la configuración de Snapchain lee como humantime, así que el <n>d que escribe casty es 30d para 30 días.

Grafana

El archivo compose de Snapchain incluye Grafana. casty arranca solo snapchain y statsd, pero prepara Grafana para que un solo comando lo arranque con el dashboard de Snapchain ya en su sitio: en el host, ejecuta docker compose up -d grafana en ~/snapchain. El override lo publica en el loopback del host, así que llega a él por SSH:

ssh -L 3000:127.0.0.1:3000 <user>@<node ip>   # then open http://127.0.0.1:3000

El dashboard se abre sin iniciar sesión (el grafana.ini de Snapchain permite que cualquiera lo vea); para editar, inicia sesión como admin con la contraseña que contiene GRAFANA_PASSWORD en ~/snapchain/.env. Grafana lee esa contraseña solo en su primer arranque: si definiste GRAFANA_CREDS tú mismo antes de que se ejecutara casty, define GRAFANA_PASSWORD con el mismo valor.

Opciones

Usage: 1-node.sh [up|status|logs|tunnel|upgrade|serve|down] [options]

  (no command)            up, wait for sync, then open the tunnel
  up                      check the host, write ~/snapchain, start the node, wait for sync
  status [--wait]         sync progress per shard; --wait polls until synced
  logs [casty]            follow the node's logs, or the casty service's
  tunnel [--stop]         forward local ports 3381 and 3383 to the node over SSH
  upgrade                 fetch the latest release's compose file (or --release) and restart
  serve                   run casty on the host, reached over HTTPS from any network: needs
                          --domain <name> (Caddy gets the certificate; open 80 and 443 with
                          0-provision.sh --https) or --tailscale (tailscale serve on the host)
  down                    stop the node, and casty if it serves

  --fid <fid>             your fid, recorded as HUB_OPERATOR_FID (default: 0)
  --autoupgrade           install snapchain.sh's weekly auto-upgrade (needs --fid). It runs
                          docker system prune --volumes -f on the whole host.
  --block-retention <n>   prune blocks older than n days (read nodes only)
  --release <version>     run this Snapchain release, such as 0.14.3, instead of the latest
  --no-tunnel             do not open the tunnel after sync
  --timeout <seconds>     how long status --wait waits (default: 43200, 12 hours)
  --env <file>            node.env from step 0 (default: node.env)
  --dry-run               print the ssh commands instead of running them
  serve:
  --domain <name>         the name the page is reached at; must point at the host
  --tailscale             reach it as the host's name on your tailnet instead
  --read-only             a page that reads only: no app key or passphrase leaves this machine
  --config <dir>          casty's config directory here (default: $XDG_CONFIG_HOME/casty)

Exit codes: 0 ok, 1 not synced or the node did not answer, 2 bad arguments, 3 missing prerequisite,
4 no ssh connection or download failed, 5 preflight failed.

Siguiente: 2. Instalar el cliente.