---
# System prepended metadata

title: '#Series: Corre tu nodo de Bitcoin, sin excusas.   Corre tu nodo de Bictoind paso a paso'

---

---
title: '#Series: Corre tu nodo de Bitcoin, sin excusas.  
Corre tu nodo de Bictoind paso a paso'
disqus: hackmd
---

# Librería de Satoshi
Lightning Tutorial como levantar tu nodo desde cero paso a paso
Autores: @decentralizedb @bitao36 @dulce 
===
ToDo Agregar imagen

## Tabla de contenido

[TOC]

## Cómo empezar

Si eres totalmente nuevo en Bitcoin te recomendarmos leer: 

ToDo: Lecturas recomendadas

4. Sigue el resto de esta guía

Instalar librerias y utilities
---



# Como instalar un nodo completo de Bitcoin con LND desde cero en Linux Ubuntu con Tor 

Hay cuatro formas de instalar un nodo de Bitcoin, voy a enumerarlas empezando de la más fácil a la más difícil:

1.Con software plug & play como [Umbrel](https://getumbrel.com), [RaspiBlitz](https://raspiblitz.org), [Runcitadel](https://runcitadel.space) o similares. 
Estos programas tienen instaladores para raspberry pi y también pueden correr en pcs con sistema linux.
En el caso de Umbrel y Runcitadel instala un contenedor docker con Bitcoin Core y la implementación LND de Lightning network por defecto usando Tor. Lo cual le da facilidad a usuarios no técnicos de correr un nodo de forma muy simple y con privacidad por defecto.

2.Instalar a partir de contenedores docker. La cual requiere algún conocimiento más técnico.

3.Instalación a partir de binarios ya compilados. En bitcoin.org hay instaladores binarios para varios sistemas operativos, es cuestión de descargarlos y seguir las instrucciones.

4.Bajar el código fuente, compilarlo e instalar.

En este tutorial vamos a desarrollar el punto 4, que puede ser retador para personas no técnicas. Si eres un usuario técnico o no tan técnico pero con muchos deseos de aprender entonces este tutorial es para ti.

Como requisito para este tutorial, debes haber instalado previamente una versión de Linux, en nuestro caso nos vamos a basar en Ubuntu, por ser una distribución ampliamente usada por la comunidad de desarrolladores de Bitcoin y tener una base bastante extendida de información y tutoriales basados en esta distro.


Vamos a empezar con una instalación desde cero, es importante que el usuario con el que vayas a trabajar tenga permisos de administrador en el sistema, ya que vamos a tener que instalar algunos paquetes necesarios para que todo nuestro software funcione. En Linux es muy habitual que el usuario principal sea a su vez un usuario administrador, así que no deberías tener problemas si ya tienes creado un usuario, ya que seguramente sea administrador.

En este caso, nuestro usuario a usar se llama ***admon*** y está agregado al grupo sudo para que pueda ejecutar comandos sudo.

Para confirmar si el usuario está agregado al grupo sudo ejecuta este comando cambiando admon por tu usuario

`$ groups admon`


![](https://i.imgur.com/R7Eb1Oj.png)


En caso de que el resultado anterior no se encuentre el grupo sudo agrégalo con el siguiente comando

`$ sudo usermod -a -G sudo admon`

## Instalar programas, librerías  y dependencias

**Programas que necesitamos**

Vamos a instalar estos dos programas que los necesitaremos más adelante:

`$ sudo apt-get install git`
`$ sudo apt-get install curl`


## Instalar Tor

Vamos a usar Tor, no sólo por la privacidad, sino porque de esa forma no
tenemos que hacer ninguna redirección de puertos en el router que tengamos y tampoco usar servicios dns dinámico para que se refresque nuestra ip en 
caso de que sea fija, que es el caso más típico en caso de instalaciones de internet domésticas.

Ahora instalaremos Tor y lo dejaremos listo para cuando lo necesitemos más adelante.

Ejecutamos el siguiente comando para saber el nombre de la distribución linux que estamos usando:

`$ lsb_release -c`

Y obtendremos como resultado el nombre como se puede ver en este ejemplo:
`admon@lndserver:~$ lsb_release -c`
`Codename:	jammy`



Ahora vamos a crear el siguiente archivo

`$ sudo nano /etc/apt/sources.list.d/tor_repo.list`

Edita donde dice jammy por lo que te haya aparecido a ti y copias allí
las siguiente líneas para poder bajar los repositorios en donde se aloja el código fuente

```gherkin=
deb     [arch=amd64 signed-by=/usr/share/keyrings/deb.torproject.org-keyring.gpg] https://deb.torproject.org/torproject.org jammy main
deb-src [arch=amd64 signed-by=/usr/share/keyrings/deb.torproject.org-keyring.gpg] https://deb.torproject.org/torproject.org jammy main
```

presiona Ctrl+x , luego presiona 's' y enter para guardar los cambios.

Ahora ejecuta el siguiente comando para bajar la llave GPG del repositorio para poderla instalar:

`$ curl https://deb.torproject.org/torproject.org/A3C4F0F979CAA22CDBA8F512EE8CBC9E886DDD89.asc | sudo apt-key add -`

Ejecutamos este comando para actualizar los repositorios que acabamos de añadir:

`$ sudo apt-get update`

E instalamos:

`$ sudo apt-get install tor deb.torproject.org-keyring`

Ahora vamos a editar el archivo de configuración torrc

`$ sudo nano /etc/tor/torrc`

Y añadimos las siguientes líneas

```gherkin=
SOCKSPort 9050
Log notice stdout
ControlPort 9051
CookieAuthentication 1 
CookieAuthFileGroupReadable 1 
```
Y salvamos, presiona Ctrl+x , luego presiona 's' y enter para guardar los cambios.

Ahora vamos a añadir el usuario en donde está la instalación de bitcoin al grupo de Tor. Con este comando encontramos el nombre del Tor group.

`$ grep User /usr/share/tor/tor-service-defaults-torrc`

En nuestro caso aparece debian-tor, entonces añadimos el usuario ***admon*** a este grupo:

`$ sudo usermod -a -G debian-tor admon`

Ahora vamos a configurar Tor para que arranque cada vez que inicie el pc:

`$ sudo systemctl enable tor`

Y para lanzarlo en este momento ejecutamos

`$ sudo systemctl start tor`

En este punto es recomendable reiniciar el pc para que se tomen todos los cambios he instalaciones realizadas al momento.

Una vez reiniciado el equipo, la máquina está corriendo Tor. El tráfico es normal a menos que le especifiques al software de comunicaciones que estés usando que se conecte a través de Tor como lo haremos más adelante con bitcoind y LND.


**Librerías y dependencias**


Ahora necesitamos instalar algunas librerias. Al instalar librerias, a veces se puede enumerar muchas en un solo comando y separarlas con un solo espacio. En este tutorial, los dividí en grupos similares a la documentación de compilación en [Github para Debian/Ubuntu](https://github.com/bitcoin/bitcoin/blob/master/doc/build-unix.md)

Ejecuta los siguientes comandos para instalar todas las librerías que ayudarán a compilar el código de bitcoind y que también servirán en caso de que quieras usar herramientas para aprender a desarrollar.

```gherkin=
$ sudo apt-get install build-essential autoconf libtool autotools-dev automake pkg-config bsdmainutils python3 libevent-dev
$ sudo apt-get install libboost-system-dev libboost-filesystem-dev libboost-test-dev libboost-thread-dev
$ sudo apt-get install libsqlite3-dev
$ sudo apt-get install libminiupnpc-dev
$ sudo apt-get install libzmq3-dev
$ sudo apt-get install libqrencode-dev
```

En caso de que quieras usar GUI(interfaz gráfica) para administrar bitcoind debes instalar estas librerías, si solo vas a usar la línea de comando no es necesario.

`$ sudo apt-get install libqt5gui5 libqt5core5a libqt5dbus5 qttools5-dev qttools5-dev-tools`

## Compilar e instalar bitcoind

Verificamos que estamos en el home del usuario actual:

`$ cd ~`

Y ejecutamos este comando para bajar el código del repositorio de Bitcoin:

`$ git clone https://github.com/bitcoin/bitcoin.git`

Una vez terminada la descarga, nos cambiamos a la carpeta bitcoin que se acaba de crear ejecutando el comando:

`$ cd bitcoin`

Miramos los tags para ver las versiones disponibles con este comando

`$ git tag`

También puedes mirar la versión del último release en esta url:
[https://github.com/bitcoin/bitcoin/releases](https://github.com/bitcoin/bitcoin/releases)

![](https://i.imgur.com/TfCH0YU.png)



En este caso vamos a ir a la última versión que es la v23.0 para eso ejecutamos este comando 

`$ git checkout v23.0`

**Instalamos la Berkeley Database**
Esta es una base de datos que aún se necesita para poder compilar, posiblemente no se necesite en el futuro.

Instalamos la base de datos Berkeley con este comando (recuerda que debemos estar en el directorio bitcoin):

``$ ./contrib/install_db4.sh `pwd` ``

Con el siguiente comando exportamos la ruta donde quedó la base de datos en una variable de entorno BDB_PREFIX, esta variable la necesitamos más adelante (recuerda debes reemplazar el usuario ***admon*** por tu usuario)

`$export BDB_PREFIX='/home/admon/bitcoin/db4'`

**Empezamos el proceso de compilación**

Ahora vamos a prepar el entorno para compilar el sofware de refrencia de Bitcoin Core, para ello ejecutamos el siguiente comando:

`$ ./autogen.sh`

El anterior comando creó el script configure. A este script se le puedan pasar varios parámetros para ajustar a la medida de nuestras necesidades.

En este caso sólo le vamos a pasar los parámetros para configurar la base de datos Berkeley que ya instalamos en un paso previo.

`$ ./configure BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx-4.8" BDB_FLAGS="-I${BDB_PREFIX}/include"`

Con esta configuración vas a usar GUI (Interfaz gráfica) y requieres las librerías QT. En caso de que no quieras usar la  GUI  podemos pasarle el parámetro --with-gui=no y quedaría así:

`$ ./configure BDB_LIBS="-L${BDB_PREFIX}/lib -ldb_cxx-4.8" BDB_FLAGS="-I${BDB_PREFIX}/include" --with-gui=no`

Si todo fue bien, se deben haber creado los scripts para compilar bitcoind.
En caso de que no, mira qué librerías faltaron las instalas e intenta de nuevo.

Ahora si, vamos a compilar, para ello ejecutamos el comando:

`$ make`

Al finalizar podemos ver una imagen similar a esta
![](https://i.imgur.com/hoWDt7o.png)

Si fue bien, se habrá creado el compilado, por lo que ahora vamos a proceder con la instalación, ejecutando el comando:

`$ sudo make install`

La instalación dejará una salida por consola como la que se ve en la siguiente imagen
![](https://i.imgur.com/C2e6jbR.png)

Esto debe instalar el binario ***bitcoind*** en la ruta: /usr/local/bin/bitcoind
al igual que /usr/local/bin/***bitcoin-cli*** y /usr/local/bin/***bitcoin-qt*** en caso de que hayas decidido instalar Bitcoin Core con la interfaz gráfica (GUI).


## Configurar  el archivo bitcoin.conf

Cuando se ejecuta bitcoind por primera vez se crea un directorio .bitcoin en el home del usuario que contiene el archivo bitcoin.conf
Como aún no hemos ejecutado bitcoind vamos a crear el directorio de manera previa, para ello ejecutamos estos comandos que nos van a ayudar creando el directorio ***.bitcoin*** y cambiarnos al directorio creado:

`$ mkdir ~/.bitcoin`
`$ cd .bitcoin`

Ahora creamos el archivo de configuración bitcoin.conf con cualquier editor de texto, voy a usar nano por simplicidad

`$ nano bitcoin.conf`

Vamos a usar una configuración para instalar un nodo que contenga la historia completa de los bloques, ya que aunque se podría usar un nodo podado (un nodo que no contiene toda la historia de los bloques), es altamente recomendable hacerlo con un nodo que tenga la historia, y así no penalizar el rendimiento y el consumo del nodo.

Vamos a introducir estas líneas en el archivo de texto creado (bitcoin.conf), algunas de estas líneas están comentadas (serán ignoradas durante la ejecución del software) en esta primera instancia, pero vamos a usar más adelante):


```gherkin=

# Con este parámtero podemos definir una ruta diferente a la de por defecto para 
# almacenar la cadena, normalmente suele ser la ruta a tu disco duro externo
blocksdir=/RutaAtuDiscoExterno/.bitcoin
# Indicar que bitcoin se ejecute como daemon permite además de ejecutarlo en segundo plano
# poder ejecutar instrucciones para bitcon desde la línea de comandos.
daemon=1

# Options only for mainnet
[main]
txindex=1
assumevalid=0


```
Antes de ejecutar bitcoind en segundo plano, ten en cuenta que se empezará a bajar toda blockchain que al momento de crear este tutorial está en 400 Gigas aproximadamente. Eso demora varios días dependiendo de la conexión a internet.
Para que esta descarga sea más rápida la blockchain se bajará por la clearnet ya que no hemos configurado Tor aún.


## Ejecutar bitcoind y descargar la blockchain usando clearnet

Ahora ejecuta bitcoind como un demonio para que se ejecute en segundo plano y empiece a bajar la blockchain:

`$ bitcoind -daemon`

Para chequear el progreso usar este comando:

`$ bitcoin-cli getblockchaininfo`

Si comprobamos muy rápido es probable que bitcoin aún este cargando y verificando el índice, por lo que podríamos obtener un mensaje de error como el que se ve en la imagen:

![](https://i.imgur.com/YFDr3Dd.png)

No hay que preocuparse, espera unos segundos más tendrás un resultado como el siguiente:

![](https://i.imgur.com/BxPiGQq.png)




El parametro **verificationprogress**  te indicará el porcentaje del progreso, cuando llegue a 0.99 ya ha descargado la blockchain completa.



## Configurar bitcoind para que use exclusivamente Tor y cargue al iniciar el sistema.

Cuando haya bajado la blockchain podemos modificar la configuración para que bitcoind se comunique con los otros nodos exclusivamente a través de Tor y así tener más privacidad.

El archivo quedaría así:

```gherkin=

# Con este parámtero podemos definir una ruta diferente a la de por defecto para 
# almacenar la cadena, normalmente suele ser la ruta a tu disco duro externo
blocksdir=/RutaAtuDiscoExterno/.bitcoin
# Indicar que bitcoin se ejecute como daemon permite además de ejecutarlo en segundo plano
# poder ejecutar instrucciones para bitcon desde la línea de comandos.
daemon=1

# Options only for mainnet
[main]
txindex=1
assumevalid=0

rpcuser=admon
rpcpassword=1P4sswordFuer7e&D1ficil.,
debug=tor
onlynet=onion
proxy=127.0.0.1:9050
bind=127.0.0.1

```
Presiona Ctrl+x , luego presiona 's' y enter para guardar los cambios.

Expliquemos un poco estos parámetros:


`rpcuser` y `rpcpassword` son dos parámetros que debes ingresar y más tarde los usaremos para que el nodo de lightning se comunique por el protocolo RPC.

`debug=tor`   agrega logs que tengan que ver con tor

`onlynet=onion` le indica a Bitcoin Core que  las conexiones salientes sean sobre Tor

`proxy=127.0.0.1:9050`  le indica a Bitcoin core como comunicarse mediante Tor

`bind: 127.0.0.1` restringirá las conexiones entrantes de Bitcoin Core desde otros nodos para que solo se realicen a través de Tor. Si nunca has ejecutado un nodo antes, otros peers no intentarán conectarse con tu nodo porque no saben que existe, pero podrían hacerlo. 

Terminada la explicación del archivo de configuración procedemos a detender bitcoind:

`$ sudo bitcoin-cli stop`

Ahora los arrancamos de nuevo:

`$ sudo bitcoind -daemon`


Si ejecutamos el comando

`$ watch -t bitcoin-cli -netinfo`

![](https://i.imgur.com/5gHYWWi.png)



Podemos observar que estamos conectados mediante la red Tor ya que todas las conexiones son de tipo onion.
Con la combinación de teclas ***control + c*** (tecla "control" y la tecla "c" presionadas al mismo tiempo) matamos o paramos la ejecución del comando anterior.

#### Servicio de sistema

Si no hacemos nada más, cada vez que se reinicie el PC hay que ejecutar este comando para que bitcoind se ejecute. Por eso lo que debemos hacer es crear un servicio para que se ejecute automáticamente al iniciar el pc.

Para lograrlo vamos a la siguiente ruta:

`$ cd /etc/systemd/system`


Y ejecutamos este comando para crear el archivo que va a contener las instrucciones para que el sistema pueda iniciar bitcoin cada vez que iniciemos el equipo:

`$ sudo nano bitcoind.service`

Y vamos a poner dentro de ese nuevo archivo las siguientes líneas asegurando que quedan bien con nuestro usuario:

```gherkin=
[Unit]
Description=bitcoin
#After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=forking
Restart=on-failure
TimeoutStartSec=infinity
TimeoutStopSec=600
User=admon
Group=admon

ExecStart=/usr/local/bin/bitcoind
ExecStop=/bin/kill -15 $MAINPID

[Install]
WantedBy=multi-user.target
```

Presiona Ctrl+x , luego presiona 's' y enter para guardar los cambios.

Ejecutamos este comando para que inicie el servicio cuando se reinicie el equipo:

`$ sudo systemctl enable bitcoind.service` 

Y con este comando lo ejecutamos:

`$ sudo systemctl start bitcoind.service `

Para mirar el estado del servicio ejecutamos:

`$ sudo systemctl status bitcoind.service `

![](https://i.imgur.com/hQHKx9E.png)



Si deseamos detenerlo usamos:

`$ sudo systemctl stop bitcoind.service `

Si has llegado hasta aquí felicitaciones, ahora tienes instalado un nodo de Bitcoin instalado que te proveerá privacidad y ayudará a la descentralización de la red.


## Instalar dependencias para poder compilar LND

```gherkin=
$sudo apt-get update
$sudo apt-get install -y \
autoconf automake build-essential git libtool libgmp-dev libsqlite3-dev \
python3 python3-mako python3-pip net-tools zlib1g-dev libsodium-dev \
gettext
$sudo pip3 install --user mrkd
```


## Compilar e instalar lightning LND

lnd está escrito en un leguaje llamado ***Go*** por lo que es necesario que lo instalemos previamente a la instalación de LND.
Al momento de escribir este tutorial, la versión recomendada de Go es la 1.18, pero si quieres comprobar que versión es la última recomendada puedes revisar aquí: [Installing Go](https://github.com/lightningnetwork/lnd/blob/master/docs/INSTALL.md#installing-go). 
En nuestro caso para instalarlo, vamos a ejecutar estos comandos, primero nos iremos al directorio de home:
```
$ cd ~
```
Posteriormente ejecutaremos estos otros comandos:
```
$ wget https://dl.google.com/go/go1.18.linux-amd64.tar.gz
sha256sum go1.18.linux-amd64.tar.gz | awk -F " " '{ print $1 }'
```
La salida del comando ***sha256sum*** debería ser una cadena de texto igual a esta: e85278e98f57cdb150fe8409e6e5df5343ecb13cebf03a5d5ff12bd55a80264f. 

Si no lo fuera, eso significaría que el repositorio desde donde estamos descargando el código fuente ha sido modificado por lo que no deberías instalar esta versión de Go, revisa y si es el caso reporta en el Github de Go. Importante, esa cadena corresponde al hash de la versión 1.18, si descargas otra versión, tendrás que revisar que hash es el que le corresponde. Lo puedes revisar aquí: [Installing Go](https://github.com/lightningnetwork/lnd/blob/master/docs/INSTALL.md#installing-go)

Si coincide, entonces todo esta bien y podemos proceder con la instalación de Go ejecutando el siguiente comando desde una terminal:

```
$ sudo tar -C /usr/local -xzf go1.18.linux-amd64.tar.gz
```

Después ejecutaremos los siguientes comandos que permitirán exportar el path o ruta a donde se encuentras los binarios de Go :
```
$ export PATH=$PATH:/usr/local/go/bin
$ export GOPATH=~/gocode
$ export PATH=$PATH:$GOPATH/bin
```

Como decíamos, esto añade los path automaticamente al profile del usuario.


Ahora vamos a proceder con la instalación de LND, para ello es necesario descargar el código ejecutando el siguiente comando:
```
$ git clone https://github.com/lightningnetwork/lnd
```
Una vez descargado, nos cambiamos al directorio lnd:

`$ cd lnd`

Y ahora vamos a realizar la instalación, de lnd. Es importante saber que para instalar la última versión de lnd puedes visitar la página de versiones aquí: [lnd Releases](https://github.com/lightningnetwork/lnd/releases) y localizar la última versión (o la que quieras instalar).
No se recomienda instalar la versión que se obtiene inmediatamente al haber descargado el código (paso anterior), ya que la rama maestra puede ser inestable.
Al momento de escribir este tutorial, la última versión es la  v0.15.0-beta, así que ejemplificaremos como instalarla, ejecutando los siguientes comandos (asegurando que estamos dentro del directorio ~/lnd/):

```
$ git checkout v0.15.0-beta  #esto nos cambia a esa versión para que sea la versión a instalar
$ make install   #este comando inicia la instalación con la versión seleccionada previamente
```

Si todo ha ido bien, ya tenemos instalado el software necesario para ejecutar lnd, sin embargo antes tenemos que terminar de realizar algunas configuraciones necesarias para que lnd pueda comunicarse con bitcoind.

Así que ejecutemos el siguiente comando para crear nuestro directorio de trabajo para lnd y dentro de ese directorio crearemos un archivo con las configuraciones necesarias para que lnd trabaje sobre mainnet, la red principal de Bitcoin.

```
$ mkdir ~/.lnd
$ cd .lnd
```

Ahora crearemos el archivo lnd.conf, este archivo contiene lo minímo necesario para ejecutar nuestro nodo, si quieres conocer más sobre todas las configuraciones que puedes usar, te recomendamos que visites este link donde podrás revisarlo: [lnd.conf](https://github.com/lightningnetwork/lnd/blob/master/sample-lnd.conf)

En un terminal ejecutamos:

```
$ nano lnd.conf
```
Acontinuación nos mostrará el editor y puedes seleccionar todo el texto que ves aquí en nuestro ejemplo, copiarlo y en la terminal pulsar el botón derecho y seleccionar la opción "pegar" para copiarlo de manera más inmediata
```
 GNU nano 6.2                                                             lnd.conf  
; Configuration for lnd.
; The default location for this file is in ~/.lnd/lnd.conf
; Boolean values can be specified as true/false or 1/0.

[Application Options]

; The directory that lnd stores all wallet, chain, and channel related data
; within The default is ~/.lnd/data
datadir=~/.lnd/data

; The directory that logs are stored in. The logs are auto-rotated by default.
; Rotated logs are compressed in place.
logdir=~/.lnd/logs

; Number of logfiles that the log rotation should keep. Setting it to 0 disables deletion of old log files.
maxlogfiles=3
;
; Max log file size in MB before it is rotated.
maxlogfilesize=10

; Path to TLS certificate for lnd's RPC and REST services.
tlscertpath=~/.lnd/tls.cert

; Path to TLS private key for lnd's RPC and REST services.
tlskeypath=~/.lnd/tls.key

; Specify the interfaces to listen on for gRPC connections.  One listen
; address per line.
; Only ipv4 localhost on port 10009:
rpclisten=localhost:10009
rpclisten=[::1]:10010

; Specify the interfaces to listen on for REST connections.  One listen
; address per line.
; All ipv4 interfaces on port 8080:
restlisten=localhost:8080

; Debug logging level.
; Valid levels are {trace, debug, info, warn, error, critical}
; You may also specify <global-level>,<subsystem>=<level>,<subsystem2>=<level>,... 
; to set log level for individual subsystems.  Use lncli debuglevel --show to 
; list available subsystems.

debuglevel=debug,PEER=info

; The smallest channel size (in satoshis) that we should accept. Incoming
; channels smaller than this will be rejected, default value 20000.
minchansize=1000000

; The largest channel size (in satoshis) that we should accept. Incoming
; channels larger than this will be rejected. For non-Wumbo channels this 
; limit remains 16777215 satoshis by default as specified in BOLT-0002.
; For wumbo channels this limit is 1,000,000,000 satoshis (10 BTC).
; Set this config option explicitly to restrict your maximum channel size
; to better align with your risk tolerance
; maxchansize=

; If true, spontaneous payments through keysend will be accepted. [experimental]
accept-keysend=true

; The alias your node will use, which can be up to 32 UTF-8 characters in
; length.
alias=DecentralizedEducation ⚡

[Bitcoin]

; If the Bitcoin chain should be active. Atm, only a single chain can be
; active.
bitcoin.active=true

; Use Bitcoin's main network.
;bitcoin.mainnet=true

; Use Bitcoin's test network.
bitcoin.testnet=true

; Use the bitcoind back-end
bitcoin.node=bitcoind

[Bitcoind]

; The base directory that contains the node's data, logs, configuration file,
; etc.
bitcoind.dir=/home/admon/.bitcoin

; The host that your local bitcoind daemon is listening on. By default, this
; setting is assumed to be localhost with the default port for the current
; network.
bitcoind.rpchost=localhost

; Username for RPC connections to bitcoind. By default, lnd will attempt to
; automatically obtain the credentials, so this likely won't need to be set
; (other than for a remote bitcoind instance).
bitcoind.rpcuser=admon

; Password for RPC connections to bitcoind. By default, lnd will attempt to
; automatically obtain the credentials, so this likely won't need to be set
; (other than for a remote bitcoind instance).
bitcoind.rpcpass=1P4sswordFuer7e&D1ficil.,

; ZMQ socket which sends rawblock and rawtx notifications from bitcoind. By
; default, lnd will attempt to automatically obtain this information, so this
; likely won't need to be set (other than for a remote bitcoind instance).
bitcoind.zmqpubrawblock=tcp://127.0.0.1:28332
bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333

[tor]
; Allow outbound and inbound connections to be routed through Tor
tor.active=true

; The port that Tor's exposed SOCKS5 proxy is listening on. Using Tor allows
; outbound-only connections (listening will be disabled) -- NOTE port must be
; between 1024 and 65535
tor.socks=9050

; Enable Tor stream isolation by randomizing user credentials for each
; connection. With this mode active, each connection will use a new circuit.
; This means that multiple applications (other than lnd) using Tor won't be mixed
; in with lnd's traffic.
tor.streamisolation=true

; Automatically set up a v3 onion service to listen for inbound connections
tor.v3=true

[healthcheck]
; The number of times we should attempt to query our chain backend before
; gracefully shutting down. Set this value to 0 to disable this health check.
healthcheck.chainbackend.attempts=0


```
Vamos a ver una breve explicación de algunos de los parámetros que hemos puesto en nuestro archivo y que es importante revisarlos. Algunos muy obvios no los comentaremos para no alargar demasiado el tutorial:

***minchansize***=1000000  -> el valor esta expresado en satoshis y es el monto mínimo que nuestro nodo va a aceptar para que otro nodo pueda abrirnos un canal, si es un monto inferior, el canal será rechazado; el mínimo por defecto es de 20000 satoshis

***alias***=Alias que quiera dar al nodo ⚡   -> Puedes asignar un alias a tu nodo para que lo puedan encontrar en algunos exploradores de nodos. Este alias no puede ser mayor a 32 caracteres.

***bitcoind.dir***=/DiscoExterno/.bitcoin   -> Si tu instalación de bitcoin no estuviera en la ruta predeterminada (~/.bitcoin), con este parámetro le puedes indicar en donde se localiza

***bitcoind.rpcuser***=admon    -> Importante!, el usuario debe ser el mismo que indicaste en tu archivo de configuración de Bitcoin Core, bitcoin.conf

***bitcoind.rpcpass***=1P4sswordFuer7e&D1ficil.,   -> Importante!, la contraseña debe ser la misma que indicaste en tu archivo de configuración de Bitcoin Core, bitcoin.conf

***tor.active***=true   -> Habilita que tanto las comunicaciones de lnd de entrada como de salida sean a través de la red de Tor, esto te proporciona mayor privacidad y además evita que tengas que tener un IP fija para comunicarte con otros nodos de LN

***tor.socks***=9050   -> Es el puerto que configuramos cuando se instalo Tor y por el que el proxy estará escuchando para comunicarse con la red Tor

***healthcheck.chainbackend.attempts***=0   -> Este parámetro estable el número de veces que lnd va a intentar conectar con bitcoin antes de realizar un apagado controlado. Recomiendo desactivarlo porque a veces las comunicaciones mediante RPC con el nodo de bitcoin dan timeout y el nodo de lnd podría apagarse, lo que implicaría que dejaríamos de estar online y un nodo de LN debe estar online para poder enviar y recibir.

Una vez tenemos configurado nuestro archivo, vamos a crear nuestra cartera de LN que es necesaria para poder operar, ya que esta cartera nos permite recibir fondos onchain (btc) desde cualquier dirección de bitcoin y abrir canales con otros nodos para enviar satoshis.

***Muy IMPORTANTE*** la creación de esta cartera nos proporcionará la semilla, que es nuestra clave privada para poder recuperar, en caso de algún problema, los fondos que en ella se tengan. Debes respaldar las 24 palabras que te propocionará con mucho cuidado y sin compartirla con NADIE. Recuerda, esas palabras son el acceso a tus fondos.

Otra cosa a considerar, es que el formato que lnd usa para crear las carteras se denomina semilla de cifrado aezeed.
El cual es similar al formato usado por la mayoría de las carteras, pero lo único que comparten es que utilizan la misma lista de palabras en inglés. Si quieres más información puedes consultarla aquí: [aezeed](https://github.com/lightningnetwork/lnd/tree/master/aezeed).

Entendido lo anterior, vamos a crear nuestra cartera.
Debemos tener inicializado bitcoin, y entonces ejecutamos en una terminal el comando para iniciar lnd. 
**Nota:** En este momento la terminal se va a quedar esperando y procesando, por lo que es importante no cerrar este terminal para no "matar" a la aplicación de lnd:

```
$ lnd
```
Una vez iniciado, vamos a crear nuestra cartera, ejecutamos en otra terminal:
```
$ lncli create
```
Si la ejecución de este comando no es reconodido por el sistema es necesario cerrar la sesión de usuario, volver a firmarse, y continuar en este punto.

Con la ejecución del comando nos será requerida una contraseña o password para crear la cartera. Esta contraseña es muy importante también conservarla ya que es la clave para poder desbloquear la cartera dentro de lnd.
Veras algo como esto, donde debes introducir y confirmar la contraseña:
```
Input wallet password:
Confirm wallet password:
```
A continuación el proceso te preguntará si ya cuentas con una semilla de 24 palabras y si quieres usarlas. Esto es en el caso de que estuvieras restaurando una semilla previamente generada, el cual no es nuestro caso, por lo que diremos que no poniendo la tecla "n" y dando a la tecla de intro

```
Do you have an existing cipher seed mnemonic or extended master root key you want to use?
Enter 'y' to use an existing cipher seed mnemonic, 'x' to use an extended master root key 
or 'n' to create a new seed (Enter y/x/n): 

```
Para mayor seguridad, las carteras permiten a los usuarios usar de manera opcional una frase de accesos adicional llamada passphrase o frase de accesos. Si decides usarla, debes tener muy claro que esa frase de acceso se convierte en parte de semilla, es como si en lugar ed tener 24 palabras, ahora tuvieras una palabra extra (25). IMPORTANTE que no la pierdas y la tengas junto con todo el resguardo de tu semilla.
Esto que parece muy complicado, es para preservar la seguridad de tus fondos, no lo tomes como algo complejo, sino como parte de la seguridad que debes tener con tu dinero, en este caso con tu bitcoin.
Veras en el terminal algo similar a lo siguiente:

```
Your cipher seed can optionally be encrypted.
Input your passphrase if you wish to encrypt it (or press enter to proceed without a cipher seed passphrase):
Confirm password:
```

```
Generating fresh cipher seed...

!!!YOU MUST WRITE DOWN THIS SEED TO BE ABLE TO RESTORE THE WALLET!!!

---------------BEGIN LND CIPHER SEED---------------
 1. one        2. two        3. three        4. four 
 5. five       6. six        7. seven        8. eight
 9. nine      10. ten       11. eleven      12. twelve 
13. thirteen  14. fourteen  15. fifteen     16. sixteen
17. seventeen 18. eighteen  19. nineteen    20. twenty
21. twentyone 22. twentytwo 23. twentythree 24. twentfour
---------------END LND CIPHER SEED-----------------

!!!YOU MUST WRITE DOWN THIS SEED TO BE ABLE TO RESTORE THE WALLET!!!

lnd successfully initialized!
```

Ya casi terminamos!
Como indicamos anteriormente, lnd se esta ejecutando en un terminal que hemos dejado abierto, ahora veremos en esa terminal que nos pide que desbloquemos la cartera si no lo hacemos, lnd no iniciará, esto es así por diseño de lnd para preservar la seguridad de los fondos en el nodo.
Por lo que en otra terminal vamos a ejecutar el comando:

`lncli unlock`

Nos pedirá desbloquear la cartera con la contraseña que hayamos escogido durante el proceso de creación de la cartera. Recuerda, la contraseña que debes poner aquí, NO es la passphrase o frase de acceso, son cosas diferentes (aunque hayas elegido la misma).

Con esto, ya el nodo de lnd debe empezar a ejecutarse, si la cadena de bitcoin esta sincronizada e indexada, podrás empezar a operar inmediatamente. Aunque nos faltan algunas cosas de configuración que veremos a continuación.
Si quieres revisar que el nodo de lnd esta operativo en la terminal de comandos donde desbloqueaste la cartera podrías probar con el siguiente comando:

`$ lncli getinfo`

Y verías una salida smilar a esto:

```
{
    "version": "v0.15.0-beta commit=healthcheck/v1.2.-g8109c9ccf",
    "commit_hash": "8109c9ccf1e41b32234b2372d09aa83b20d65d63",
    "identity_pubkey": "673ba124ef2qv1a6712345bcesfbfbbfa64e9867cf701de1e35f6e809449123456",
    "alias": "Tu alias ⚡",
    "color": "#3399ff",
    "num_pending_channels": 0,
    "num_active_channels": 0,
    "num_inactive_channels": 0,
    "num_peers": 0,
    "block_height": 736815,
    "block_hash": "000000000000000000026ddef3daf31b5762c8f7ea59d7211ff2b4ea387dc139",
    "best_header_timestamp": "1652810595",
    "synced_to_chain": true,
    "synced_to_graph": true,
    "testnet": false,
    "chains": [
        {
            "chain": "bitcoin",
            "network": "mainnet"
        }
    ],
    "uris": [
        "673ba124ef2qv1a6712345bcesfbfbbfa64e9867cf701de1e35f6e809449123456@ab2aqwsftrlabhsif1aqfrzxy2oa1hjystg6ns7lhjytbnspla26wipa.onion:9735"
    ],
    ........
}
```
Recuerda, la salida es solo de ejemplo, los datos serán diferentes, y los datos importantes son:

***identity_pubkey***   -> Es la clave publica que podrás compartir para que otros nodos te localicen
***uris***   -> Es la dirección completa que facilita a otros nodos el poder abrir canales con el tuyo. En este caso la dirección se compone del identity_pubkey + @ + la dirección Tor onion que lnd creo para este nodo.


!Felicitaciones ahora tienes corriendo un nodo lnd¡


Con este comando podemos detener lnd

`$ lncli stop`

Si no hacemos nada más, cada vez que se reinicie el PC hay que ejecutar los comandos para iniciar bitcoin, lnd y desbloquear la cartera. Por eso lo que debemos hacer es crear servicios para que se ejecuten automáticamente al iniciar el pc.


Así que vamos a crear los servicios. Vamos a la siguiente ruta:

`$ cd /etc/systemd/system`

Y ejecutamos este comando para crear el archivo de configuración del servicio
`$ sudo nano lnd.service`

Ahora vamos a incluir dentro de ese archivo las siguientes líneas:

```
[Unit]
Description=LND Lightning Daemon

Requisite=network-online.target
Requires=bitcoind.service
After=network-online.target
After=bitcoind.service

[Service]
ExecStart=/home/admon/go/bin/lnd
ExecStop=/home/admon/go/bin/lncli stop
PIDFile=/home/admon/.lnd/lnd.pid

User=admon
Group=admon

Type=simple
KillMode=process
TimeoutStartSec=60
TimeoutStopSec=60
Restart=always
RestartSec=60

[Install]
WantedBy=multi-user.target
```

presiona Ctrl+x , luego presiona 's' y enter para guardar los cambios.

Ejecutamos este comando para que inicie el servicio cuando se reinicie el equipo:

`$ sudo systemctl enable lnd.service` 

Y con este comando lo ejecutamos:

`$ sudo systemctl start lnd.service `


Para mirar el estado del servicio ejecutamos:

`$ sudo systemctl status lnd.service `

![](https://i.imgur.com/wl4G25q.png)


Si deseamos detenerlo usamos: 

`$ sudo systemctl stop lnd.service `



Si has llegado hasta aquí muchas felicitaciones, tienes corriendo un nodo con Bitcoin core y lnd, ahora tienes tu propio banco, y por primer vez en la historia podrás tener soberanía monetaria.