Electrs

Configurarem Electrs com a servidor Electrum complet per utilitzar-lo amb el vostre programari o dispositiu de signatura de Bitcoin.

Preparacions

Instal·leu dependències

Aquestes són dependències de construcció (es pot eliminar després de la instal·lació, si voleu)

$SU apk add --virtual .build-deps cargo cargo-auditable clang-dev cmake git \
    gnupg rocksdb-dev

Aquestes són dependències en temps d’execució

$SU apk add rocksdb

Creeu l’usuari/grup `electrs`

$SU addgroup -S electrs

$SU adduser \
    -S \
    -D \
    -H \
    -h /dev/null \
    -s /sbin/nologin \
    -G electrs \
    -g electrs \
    electrs

Afegeix l’usuari `electrs` al grup `bitcoin`

$SU adduser electrs bitcoin

Afegiu també l’usuari `satoshi` al grup `electrs`

$SU adduser satoshi electrs && exec su -l satoshi

Servidor intermediari invers

A la secció Seguretat, ja hem configurat un servidor intermediari invers. Ara podem afegir la configuració del servidor Electrum.

Habiliteu el servidor intermediari invers per afegir xifratge SSL/TLS a la comunicació del servidor Electrum. Creeu el fitxer de configuració i enganxeu el contingut següent

$SU $EDITOR /etc/caddy/streams/electrum.caddy

/etc/caddy/streams/electrum.caddy

:50002 {
        route {
                tls 
                proxy {
                        upstream 127.0.0.1:50001
                }
        }
}

Torna a carregar el Caddy

$SU rc-service caddy reload

Tallafoc

Configura el tallafoc per permetre les sol·licituds entrants

$SU $EDITOR /etc/awall/optional/electrum.json

/etc/awall/optional/electrum.json

{
  "description": "Allow Electrum SSL",
 
  "filter": [
    {
      "in": "internet",
      "out": "_fw",
      "service": { "proto": "tcp", "port": 50002 },
      "action": "accept",
      "conn-limit": { "count": 10, "interval": 60 }
    }
  ]
}

Habilitar-ho

$SU awall enable electrum
$SU awall activate

Instal·lació

Una manera fàcil i eficient d’executar un servidor Electrum és utilitzar Electrs, el servidor Electrum fet en Rust. No hi ha binaris disponibles, així que compilarem l’aplicació nosaltres mateixos.

Descarrega el codi font

Obtenim l’última versió del codi font d’Electrs, el verifiquem, el compilem en un binari executable i l’instal·lem.

Baixeu el codi font de la darrera versió d’Electrs. Podeu consultar la pàgina de llançament per veure si hi ha disponible una versió més recent. Tanmateix, és possible que altres versions no s’hagin provat correctament amb la resta de la configuració de Microbolt.

cd /tmp

VERSION=0.10.6

git clone --branch v$VERSION https://github.com/romanz/electrs.git && cd electrs

Comprovació de la signatura

Per evitar l’ús d’un codi font maliciós, verifiqueu que la versió hagi estat signada correctament pel desenvolupador principal Roman Zeyde.

wget -qO- https://romanzey.de/pgp.txt | gpg --import

git verify-tag v$VERSION

Configurar, compilar i instal·lar

Ara compileu el codi font en un binari executable i instal·leu-lo.

cargo auditable build \
    --bin electrs \
    --features "metrics_process" \
    --release \
    --locked \
    --jobs "$(nproc)"

$SU install -m 0755 -o root -g root -t /usr/bin ./target/release/electrs

$SU install -D -m 0660 -o electrs -g electrs ./doc/config_example.toml /etc/electrs/config.toml

”Strip” els binaris instal·lats

$SU strip -v /usr/bin/electrs

Neteja

cd
$SU rm -rf /tmp/electrs
$SU apk del .build-deps

Configuració

Modifiqueu el fitxer de configuració amb el contingut següent

$SU $EDITOR /etc/electrs/config.toml

/etc/electrs/config.toml

[...]
cookie_file = "/var/lib/bitcoind/.cookie"
[...]
#db_dir = "/some/fast/storage/with/big/size"
[...]
daemon_dir = "/var/lib/bitcoind"

Accés remot per Tor

Per utilitzar el vostre servidor Electrum quan esteu en remot, podeu crear fàcilment un servei ocult Tor. D’aquesta manera, podeu connectar la cartera BitBoxApp o Electrum també de manera remota, o fins i tot compartir els detalls de la connexió amb amics i familiars. Tingueu en compte que el dispositiu remot també ha de tenir Tor instal·lat.

Afegiu les línies següents a la secció de “location-hidden services” al fitxer torrc.

$SU $EDITOR /etc/tor/torrc

/etc/tor/torrc

# Hidden Service Electrum
HiddenServiceDir /var/lib/tor/electrum/
HiddenServiceVersion 3
HiddenServicePoWDefensesEnabled 1
HiddenServicePort 50002 127.0.0.1:50002

Torneu a carregar la configuració de Tor i obteniu la vostra adreça de connexió.

$SU rc-service tor reload
$SU cat /var/lib/tor/electrum/hostname

output

abcdefg..............xyz.onion

Ara hauríeu de poder connectar-vos al vostre servidor Electrum de manera remota mitjançant Tor, el vostre nom d’amfitrió i el port 50002

Inici automàtic a l’arrencada

Electrs s’ha d’iniciar automàticament a l’arrencada del sistema.

Creeu la unitat d’Electrs init.d i copieu/enganxeu la configuració següent

$SU $EDITOR /etc/init.d/electrs

/etc/init.d/electrs

#!/sbin/openrc-run
 
: ${ELECTRS_CONFIGFILE:=/etc/electrs/config.toml}
: ${ELECTRS_DATADIR:=/var/lib/electrs}
: ${ELECTRS_LOGDIR:=/var/log/electrs}
: ${ELECTRS_USER:=electrs}
: ${ELECTRS_GROUP:=electrs}
: ${ELECTRS_BIN:=/usr/bin/electrs}
: ${ELECTRS_OPTS=${ELECTRS_OPTS}}
: ${ELECTRS_SIGTERM_TIMEOUT:=600}
 
ELECTRS_PIDDIR="/run/electrs"
 
required_files="${ELECTRS_CONFIGFILE}"
pidfile="${ELECTRS_PIDDIR}/${SVCNAME}.pid"
retry="${ELECTRS_SIGTERM_TIMEOUT}"
 
name="Electrs"
description="Efficient re-implementation of Electrum Server in Rust"
 
command="${ELECTRS_BIN}"
command_args="--conf ${ELECTRS_CONFIGFILE}
              --skip-default-conf-files
              --db-dir ${ELECTRS_DATADIR}
              --timestamp
              --skip-block-download-wait
              ${ELECTRS_OPTS}"
command_user="${ELECTRS_USER}:${ELECTRS_GROUP}"
command_background="true"
 
start_stop_daemon_args="--stdout ${ELECTRS_LOGDIR}/debug.log
                        --stderr ${ELECTRS_LOGDIR}/debug.log"
 
depend() {
    use bitcoind
    after bitcoind
}
 
start_pre() {
    checkpath --file      --mode 0660 --owner "${command_user}" "${ELECTRS_CONFIGFILE}"
    checkpath --directory --mode 0750 --owner "${command_user}" "${ELECTRS_DATADIR}"
    checkpath --directory --mode 0755 --owner "${command_user}" "${ELECTRS_LOGDIR}"
    checkpath --directory --mode 0755 --owner "${command_user}" "${ELECTRS_PIDDIR}"
    checkconfig
}
 
start_post() {
    checkpath --file --owner "${command_user}" "${pidfile}"
}
 
checkconfig() {
    if ! grep -qs '^cookie_file = ' "${ELECTRS_CONFIGFILE}"
    then
        eerror ""
        eerror "ERROR: You must set a cookie_file path to run Electrs."
        eerror "The setting must appear in ${ELECTRS_CONFIGFILE}"
        eerror ""
        return 1
    fi
}

Habilita el permís d’execució

$SU chmod +x /etc/init.d/electrs

Habilita logrotate

Introduïu la configuració següent completa. Guardar i sortir

$SU $EDITOR /etc/logrotate.d/electrs

/etc/logrotate.d/electrs

/var/log/electrs/*.log {
    weekly
    missingok
    rotate 104
    compress
    delaycompress
    notifempty
    create 0640 electrs electrs
    sharedscripts
    postrotate
        kill -HUP `cat /run/electrs/electrs.pid`
    endscript
}

Prova

$SU logrotate /etc/logrotate.d/electrs --debug

Activa i inicia Electrs

$SU rc-update add electrs

$SU rc-service electrs start

Comproveu el registre per veure la sortida d’Electrs. Sortiu amb Ctrl-C

tail -f /var/log/electrs/debug.log

Ara Electrs indexarà tota la cadena de blocs de Bitcoin perquè pugui proporcionar tota la informació necessària als dispositius de signatura. Amb això, els dispositius de signatura que utilitzeu ja no necessiten connectar-se a cap servidor de tercers per comunicar-se amb la xarxa peer-to-peer de Bitcoin.

Per al futur: actualització d’Electrs

Torneu a seguir la pàgina Electrs substituint el valor de la variable d’entorn VERSION=x.xx per l’últim si encara no s’ha modificat en aquesta guia.

Actualitzeu la configuració d’Electrs si cal (vegeu les notes de la versió)

$SU $EDITOR /etc/electrs/electrs.toml

Reinicieu el servei per aplicar els canvis

$SU rc-service electrs restart

Fulcrum Aplicació de signatura d'escriptori