Einstellung einer Near Shardnet Validator und Monitoring davon

Schon lange her habe ich bei dem Guildnet von Near angefangen. Ich kann mich noch dran erinnern wie schwierig für mich es war zu vestehen, wie man das ganze so installiert und konfiguriert.

NEAR in sich braucht überhaupt keine Vorstellung als L1 Blockchain. Es hat alles was man braucht, ist stabil und ermöglich viele Entwicklungsmöglichkeiten. Jetzt, um die Erweiterungskapazitäten zu verbessern, kommen “shards” (so wie Schnitte) dazu. Dann mehrere schards kommen in einen Block rein.

Also, gehen wir zu den Schritten um einen Validator auf dem Shardnet (neues Testnet von Near) auf die Beine zu stellen:

Erzeugung des Wallets

Near hat eine web-bassierte Wallet. Wir müssen ein neues Wallet für Shardnet erzeugen:

https://wallet.shardnet.near.org

Wir klicken auf “Create Account” und dann müssen wir einen freinen Namen auswählen. Zum Beispiel bloclicktestkonto:

Dann müssen wir wie immer in solchen Fällen die ‘seeds’ von diesem Wallet offline speichern.

Um dann einzulogen brauchen wir die 12 Wörter:

Beim Shardnet wird jedes Konto mit ungefähr 2000 NEAR testnet tokens gefundet:

Also, unser Wallet ist fertig, machen wir weiter.

Jetzt werden wir in unser Node near cli installieren. Es ermöglicht auch wenn man kein Validator ist, mit dem Blockchain verschiedene Transaktionen durchzuführen.

Auswahl von hw ist hier out of scope, aber ein AX41 bei Hetzner kostet ungefähr 40 EUR pro Monat. Near mag Contabo nicht, also, Vorsicht. Lieber bare metal als VPS.

Near client installieren

Diese sind die Schritte die wir durchführen müssen:

# NodeJS installieren als Voraussetzung: 
sudo apt update -ycurl -sL https://deb.nodesource.com/setup_18.x | sudo -E bash -  
sudo apt install build-essential nodejs
PATH="$PATH"
# Jetzt müssen wir checken dass wir beides, NODE und NPM haben:
node -v
npm -v
# Und jetzt kommt das Near client:
sudo npm install -g near-cli
# Stakewars braucht bestimmte environment variables:
export NEAR_ENV=shardnet
echo 'export NEAR_ENV=shardnet' >> ~/.bashrc
# Und jetzt checken dass alles richtig installiert ist:
near proposals
#oder mit
near validators current

Damit werden wir sehen, ob unser Near auf dem richtigen Chain steht (mainnet, testnet, guildnet, shardnet, etc.)

Near node Einstellung und Konfigurierung

Jetzt kommen für auf die Tatsächliche Einstellung des Nodes:

# Zuerst müssen wir prüfen ob unser CPU unterstützt ist:
lscpu | grep -P '(?=.*avx )(?=.*sse4.2 )(?=.*cx16 )(?=.*popcnt )' > /dev/null \
  && echo "Supported" \
  || echo "Not supported"
# Sämtliche Software das fürs Compilen notwendig ist installieren:
sudo apt install -y git binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev cmake gcc g++ python docker.io protobuf-compiler libssl-dev pkg-config clang llvm cargo
sudo apt install python3-pip
USER_BASE_BIN=$(python3 -m site --user-base)/bin
export PATH="$USER_BASE_BIN:$PATH"
sudo apt install clang build-essential make
# Jetzt rust installieren:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shsource $HOME/.cargo/env

# Also jetzt Near herunterziehen und installieren/kompilieren:
git clone https://github.com/near/nearcore
cd nearcore
git fetch
git checkout mastercargo build -p neard --release --features shardnet

# Jetzt, nur ein Mal, muss man das Node "initieren" und Genesis von Shardnet herunterziehen:
./target/release/neard --home ~/.near init --chain-id shardnet --download-genesis
# und jetzt config.json herunterziehen, sonst haben wir keine Bootnodes:
rm ~/.near/config.json
wget -O ~/.near/config.json https://s3-us-west-1.amazonaws.com/build.nearprotocol.com/nearcore-deploy/shardnet/config.json
# Optional können wir ein Snapshot vom Blockchain herunterziehen, dann werden wir schneller unser Node aufsyncen:
sudo apt-get install awscli -y
cd ~/.near
aws s3 --no-sign-request cp s3://build.openshards.io/stakewars/shardnet_noarchive/data.tar.gz .  
tar -xzvf data.tar.gz

# Und, tada, jetzt near starten: 
cd ~/nearcore
./target/release/neard --home ~/.near run

Node als Validator aktivieren

Diese Shcritte können wir nur tun, wenn wir 100% gesynct sind, sonst wird nichts tun.

Near muss lokal Zugriffsgenehmigungen für unser Wallet haben. Dass schaffen wir mit:

near login

Da kommt ein URL aus die wir dann auf unser Browser am PC nutzen müssen:

Dann werden wir diese Inhalte am Browser sehen:

Auf “Next” draufklicken und dann wieder mal auf “Connect”:

am CLI (linux) den Namen unser wallet eintragen:

Jetzt das unser Node mit unserem Wallet verbunden ist können wir unser Validator erzugen:

# Validator key erzeugen:
near generate-key bloclick
cp ~/.near-credentials/shardnet/bloclick.json ~/.near/validator_key.json
# Dann mit vi oder nano oder vim die Inhalte von validator_key.json modifizieren. Anstatt private_key soll es secret_key lauten:
{
  "account_id": "bloclick.factory.shardnet.near",
  "public_key": "ed25519:-----a-b-c-d-------------",
  "secret_key": "ed25519:****"
}
# Und jetzt near neustarten:
target/release/neard run

Jetzt dass wir gesehen haben ob alles richtig tut, müssen wir Control-C machen und ein servicefile für Near erzeugen:

#<USER> ist der Name des Users womit wir alles bisher gemacht haben
sudo nano /etc/systemd/system/neard.service
[Unit]
Description=NEAR Shardnet Service
[Service]
Type=simple
User=<USER>
#Group=near
WorkingDirectory=/home/<USER>/.near
ExecStart=/home/<USER>/nearcore/target/release/neard run
Restart=on-failure
RestartSec=30
KillSignal=SIGINT
TimeoutStopSec=45
KillMode=mixed
[Install]
WantedBy=multi-user.target
sudo systemctl enable neard
sudo systemctl start neard
# Die logs vom Service kann man sich damit anschauen:
journalctl -n 100 -f -u neard

Erzeugung des Staking Pool

Wir müssen jetzt ein Staking Pool für unseren Validator erzeugen. zB in Mainnet können dann die Users mit uns Ihre Near Tokens staken:

near call factory.shardnet.near create_staking_pool '{"staking_pool_id": "bloclick", "owner_id": "blockscope.shardnet.near", "stake_public_key": "ed25519:5M8boq4XsjgNoFiZ1digEfnJihsTaMLMyP61WbwCMcUu", "reward_fee_fraction": {"numerator": 5, "denominator": 100}, "code_hash":"DD428g9eqLL8fWUxv8QSpVFzyHi1Qd16P8ephYCTmMSZ"}' --accountId="bloclick.shardnet.near" --amount=30 --gas=300000000000000

Die Transaktion kann man danach im Explorer sehen:

NEAR Explorer | Transaction

Jetzt können wir mehr Tokens auf unser Staking Pool delegieren:

near call bloclick.factory.shardnet.near deposit_and_stake --amount 2300 --accountId bloclick.shardnet.near --gas=300000000000000

Auf dem Explorer kann man Sie auch sehen:

NEAR Explorer | Transaction

Alle notwendige Befehle sind hier zu finden:

https://github.com/near/stakewars-iii/blob/main/challenges/003.md

Ping für unser Pool

Wir müssen periodisch unser Pool ‘pingen’. Das heisst, sie am Leben zu halten.

Das kann man mit einem Cron-Job erreichen:

crontab -e
@daily  NEAR_ENV=shardnet && near call bloclick.factory.shardnet.near ping '{}' --accountId bloclick.shardnet.near  --gas=300000000000000

Dann, nach zwei Epoche wir unser Validator auf Proposal gehen, dann Joining, dann Aktiv. So sieht es aus am Ende:

Unser Node können wir hier finden:

Nodes

Monitoring vom Validator

Es gibt also viele Möglichkeiten ein Near Node zu monitoren. Ich werde mal eine ganz einfache Möglichkeit darstellen, und zwar mit einem Discord Webhook:

#!/bin/bash ALERTS_CHANNEL=”https://discord.com/api/webhooks/858067427781771294/En7ToSuR6gkkQ-Zl-qLhOz7N......................DQLyGzIMN26DX_LGpiavfFKbHM"
while true; do 
MESSAGE2=$(near validators current | grep bloclick) 
MESSAGE=$(near validators current | head -n 4) curl -d “content=$MESSAGE” -X POST $ALERTS_CHANNEL curl -d “content=$MESSAGE2” -X POST $ALERTS_CHANNEL 
sleep 60m
done

Da werden wir unsere Blöcke + Shardsproduktion sehen.

Danke fürs Lesen!