MMS Nodes EN

Celestia - Full Node - Performance

2023-05-14T06:43:20.968Z

Hello, everyone, this is MMS!
Today we analyzed the Full Celesita node technically, let's go.

Hardware

4 CORE/8GB RAM/500GB Proxmox VM on Hetzner AX101

AMD Ryzen 9 5950X with 16-cores and 32 threads

128GB RAM DDR4

2 x 3.84TB NVMe SSD (Software RAID 0)

Celestia version:

Semantic version: v0.9.3
Commit: 7f556f06e175267e0dd60b444a68554f592710a0

Start Testing

Time: 14:50:41 UTC

Height: 469370

Folder Size: 28621 MB

End Testing

Time: 15:50:42 UTC

Height: 469701

Folder Size: 28946 MB (+325 MB)

CPU Usage: AVG=4%, MAX=29%

Data Source: Proxmox

RAM Usage: AVG=21%, MAX=27%

Data Source: "free" command results every 10 seconds

( Total - Available ) / Total * 100%

Disk I/O Write: AVG=27,4Mb/s, MAX=658Mb/s

Data Source: Proxmox

Disk I/O Read: AVG=13,9Mb/s, MAX=650Mb/s

Data Source: Proxmox

Network In: AVG=1,46Mb/s, MAX=4,02Mb/s

Data Source: Proxmox

Network Out: AVG=1,22Mb/s, MAX=5,54Mb/s

Data Source: Proxmox

2 min TX Load (100TX per block since block 469693):

Conclusion

During the observation, load testing was carried out, after which peaks were observed on the "Disk I/O Read" graph. The rest of the metrics are within the normal range.

The folder size has increased by 325 megabytes. Based on the data received, the disk (1TB) will fill up in approximately 128 days.

Recommendation: Performance Testing

Installing Celestia nodes, setting up Rollup

2023-04-29T06:14:24.325Z

Hello, everyone on MMS airwaves!

Today we will cover the installation of all Celestia nodes (Validator, Bridge, Full, Light). We will try to understand the utility of each node, because while "Validator node" is something familiar to the Cosmos ecosystem, as validators exist in every project, it's not so straightforward and unambiguous with Bridge, Full, and Light nodes.

We will also set up our Rollup and local Celestia network, and even write a small text query to it.

All the main information is taken from official sources:

https://docs.celestia.org/
https://rollkit.dev/docs/intro/
https://docs.ignite.com/

System requirements

Validator node

Memory: 8 GB RAM
CPU: 6 cores
Disk: 500 GB SSD Storage
Bandwidth: 1 Gbps for Download/1 Gbps for Upload

Light node

Memory: 2 GB RAM
CPU: Single Core
Disk: 25 GB SSD Storage
Bandwidth: 56 Kbps for Download/56 Kbps for Upload

Для Bridge node

Memory: 8 GB RAM
CPU: 6 cores
Disk: 1 TB SSD Storage
Bandwidth: 1 Gbps for Download/1 Gbps for Upload

Full node

Memory: 8 GB RAM
CPU: Quad-Core
Disk: 1 TB SSD Storage
Bandwidth: 1 Gbps for Download/1 Gbps for Upload

Part 1

Validator node

Let's start with the most familiar - Validator Node, also known as Consensus Full node (just without the validator installation).

In this guide, we use default ports, but if they are occupied, you can use our guide on changing ports.

In general, there are no pitfalls here, everything is the same as in a regular project based on Cosmos.

Let's continue with installing additional packages.

sudo apt update && sudo apt upgrade -y

Installing additional packages

sudo apt install make clang git pkg-config libssl-dev build-essential git gcc chrony curl jq ncdu bsdmainutils htop net-tools lsof fail2ban wget -y

Install go and check the version

ver="1.20.2" && \ wget "https://golang.org/dl/go$ver.linux-amd64.tar.gz" && \ sudo rm -rf /usr/local/go && \ sudo tar -C /usr/local -xzf "go$ver.linux-amd64.tar.gz" && \ rm "go$ver.linux-amd64.tar.gz" && \ echo "export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin" >> $HOME/.bash_profile && \ source $HOME/.bash_profile && \ go version

Setting variables

CELESTIA_CHAIN="blockspacerace-0"
CELESTIA_MONIKER="your_name"
CELESTIA_WALLET="your_name"

Export them to .bash_profile

echo 'export CELESTIA_CHAIN='${CELESTIA_CHAIN} >> $HOME/.bash_profile echo 'export CELESTIA_MONIKER='${CELESTIA_MONIKER} >> $HOME/.bash_profile
echo 'export CELESTIA_WALLET='${CELESTIA_WALLET} >> $HOME/.bash_profile source $HOME/.bash_profile

Clone the repository and build the binary

cd $HOME/celestia-app/
git clone https://github.com/celestiaorg/celestia-app.git
git checkout v0.12.1
make install
mv $HOME/go/bin/celestia-appd /usr/local/bin

Initialize the node

celestia-appd init $CELESTIA_MONIKER --chain-id blockspacerace-0

Download genesis.json

wget -O $HOME/.celestia-app/config/genesis.json "https://raw.githubusercontent.com/celestiaorg/networks/master/blockspacerace/genesis.json"

Pruning setup (optional)

pruning="custom" pruning_keep_recent="1000" pruning_interval="10"

sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.celestia-app/config/app.toml sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.celestia-app/config/app.toml sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.celestia-app/config/app.toml

Setting the gas price

sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.001utia\"/;" ~/.celestia-app/config/app.toml

Adding seeds and peers

peers="be935b5942fd13c739983a53416006c83837a4d2@178.170.47.171:26656,cea09c9ac235a143d4b6a9d1ba5df6902b2bc2bd@95.214.54.28:20656,5c9cfba00df2aaa9f9fe26952e4bf912e3f1e8ee@195.3.221.5:26656,7b2f4cb70f04f2e9befb6ace66ce1ac7b3bea5b4@178.239.197.179:26656,7ee2ba21197d58679cfc1517b5bbc6465bed387a@65.109.67.25:26656,dc0656ab58280d641c8d10311d86627255bec8a1@148.251.85.27:26656,ccbd6262d0324e2e858594b639f4296cc4952c93@13.57.127.89:26656,a507b2bda6d2974c84ae1e8a8b788fc9e44d01f7@142.132.131.184:26656,9768290c60a746ee97ef1a5bcb8bee69066475e8@65.109.80.150:2600" sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$peers\"/" $HOME/.celestia-app/config/config.toml

seeds="0293f2cf7184da95bc6ea6ff31c7e97578b9c7ff@65.109.106.95:26656,8f14ec71e1d712c912c27485a169c2519628cfb6@celest-test-seed.theamsolutions.info:22256" sed -i.bak -e "s/^seeds *=.*/seeds = \"$seeds\"/" $HOME/.celestia-app/config/config.toml

Create a service file

sudo tee /etc/systemd/system/celestia-appd.service > /dev/null <<EOF
[Unit]
Description=celestia-appd
After=network-online.target

[Service]
User=root
ExecStart=$(which celestia-appd) start
Restart=on-failure
RestartSec=3
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

Then start and look at the logs

sudo systemctl daemon-reload && \
sudo systemctl enable celestia-appd && \
sudo systemctl restart celestia-appd && \
sudo journalctl -u celestia-appd -f -o cat

Create a wallet or restore

celestia-appd keys add $CELESTIA_WALLET
celestia-appd keys add $CELESTIA_WALLET --recover

Add wallet address to variable and export to .bash_profile

CELESTIA_ADDR=$(celestia-appd keys show $CELESTIA_WALLET -a)
echo 'export CELESTIA_ADDR='${CELESTIA_ADDR} >> $HOME/.bash_profile source $HOME/.bash_profile

Create a validator

In this testnet, only selected participants are allowed

celestia-appd tx staking create-validator \
--amount 1000000utia \
--from $CELESTIA_WALLET \
--commission-max-change-rate "0.05" \
--commission-max-rate "0.2" \
--commission-rate "0.1" \
--min-self-delegation "1" \
--pubkey $(celestia-appd tendermint show-validator) \
--moniker $CELESTIA_MONIKER \
--chain-id $CELESTIA_CHAIN

We add the address of the validator to the variable and export it to .bash_profile

CELESTIA_VALOPER=$(celestia-appd keys show $CELESTIA_WALLET --bech val -a)
echo 'export CELESTIA_VALOPER='${CELESTIA_VALOPER} >> $HOME/.bash_profile
source $HOME/.bash_profile

Since the Validator node does not make much sense in this testnet (we are talking about unauthorized users), you can always make a node for RPC / API / GPRC endpoints, now we will show how this can be done

To do this, we need to enable several options in the configs, if they are disabled.

Let's enable API/GRPC/RPC

sed -i.bak -e "117 s/^enable *=.*/enable = true/" $HOME/.celestia-app/config/app.toml -e "183 s/^enable *=.*/enable = true/" $HOME/.celestia-app/config/app.toml && cat -n $HOME/.celestia-app/config/app.toml | sed -n '117p;183p'

sed -i.bak -e '91 s/127.0.0.1/0.0.0.0/' $HOME/.celestia-app/config/config.toml && cat -n $HOME/.celestia-app/config/config.toml | sed -n '91p'

In order to find out your endpoint, you just need to substitute your server IP to a specific port, the server IP is "32.274.125.73" it will look like this:

I remind you that we do all this on default ports, if you have custom ones, change them to your own

RPC: 32.274.125.73:26657 API: 32.274.125.73:1317 GRPC: 32.274.125.73:9090

Removing Validator node / Consensus Full node

cd $HOME/
rm /usr/local/bin/celestia-appd
rm -rf .celestia-app/
rm -rf celestia-app/
rm /etc/systemd/system/celestia-appd.service

Part 2

Bridge/Full/Light nodes

Let's move on to the following types of nodes in Celestia - Light, Bridge, Full

Now we will try to briefly tell you about them.

Light node
Light clients sample data availability in the Data Availability network.

Bridge node
Bridge blocks between the Data Availability network and the Consensus network.

Fulll node
Stores all data in the Data Availability network, but is not connected to Consensus.

Since their installation does not differ much from each other, in this guide we will simply duplicate the commands, and not write a separate section for each.

We download the repository, build a binary for nodes and cel-key to generate keys.

After the "make install" command, the binary will be located along the path /usr/local/bin/celestia

cd $HOME/
git clone https://github.com/celestiaorg/celestia-node.git
cd celestia-node
git checkout tags/v0.9.3
make build
make install
make cel-key

Инициализируем

#Light
celestia light init --core.ip https://rpc-celestia-testnet.mms.team/ --p2p.network blockspacerace
#Bridge
celestia bridge init --core.ip https://rpc-celestia-testnet.mms.team/ --p2p.network blockspacerace
#Full
celestia full init --core.ip https://rpc-celestia-testnet.mms.team/ --p2p.network blockspacerace

Wallets are created during initialization, but if you want to change it / make another one, the command will be below, if you want to restore the wallet by mnemonic, add an additional "--recover" flag to the end of the command

cd celestia-node/
#Light
./cel-key add NAME_HERE --keyring-backend test --node.type light --p2p.network blockspacerace
#Bridge
./cel-key add NAME_HERE --keyring-backend test --node.type bridge --p2p.network blockspacerace
#Full
./cel-key add NAME_HERE --keyring-backend test --node.type full --p2p.network blockspacerace

Create a service file

#Light
sudo tee /etc/systemd/system/celestia-light.service > /dev/null <<EOF
[Unit]
Description=Celestia light node
After=network-online.target
[Service]
User=root
ExecStart=/usr/local/bin/celestia light start --core.ip https://rpc-celestia-testnet.mms.team/ --core.rpc.port 26660 --core.grpc.port 9090 --keyring.accname my_celes_key --metrics.tls=false --metrics --metrics.endpoint otel.celestia.tools:4318 --gateway --gateway.addr localhost --gateway.port 26667 --p2p.network blockspacerace
Restart=on-failure
RestartSec=3
LimitNOFILE=4096
[Install]
WantedBy=multi-user.target
EOF

#Bridge
sudo tee /etc/systemd/system/celestia-bridge.service > /dev/null <<EOF
[Unit]
Description=Celestia bridge node
After=network-online.target
[Service]
User=root
ExecStart=/usr/local/bin/celestia bridge start --core.ip https://rpc-celestia-testnet.mms.team/ --keyring.accname my_celes_key --core.rpc.port 26657 --core.grpc.port 9090 --metrics.tls=false --metrics --metrics.endpoint otel.celestia.tools:4318 --gateway.port 26659 --p2p.network blockspacerace --gateway --gateway.addr localhost
Restart=on-failure
RestartSec=3
LimitNOFILE=4096
[Install]
WantedBy=multi-user.target
EOF

#Full
sudo tee /etc/systemd/system/celestia-full.service > /dev/null <<EOF
[Unit]
Description=Celestia full node
After=network-online.target
[Service]
User=root
ExecStart=/usr/local/bin/celestia full start --core.ip https://rpc-celestia-testnet.mms.team/ --keyring.accname my_celes_key --core.rpc.port 26657 --core.grpc.port 9090 --metrics.tls=false --metrics --metrics.endpoint otel.celestia.tools:4318 --gateway.port 26659 --p2p.network blockspacerace --gateway --gateway.addr localhost
Restart=on-failure
RestartSec=3
LimitNOFILE=4096
[Install]
WantedBy=multi-user.target
EOF

Sometimes there may be problems with starting due to the RPC node, in this case, you can search for alternative options here and make a change in the service,
in the "--core.ip" flag, and then restart the node

Turn on the service file, restart and look at the logs

#Light
systemctl daemon-reload && \
systemctl enable celestia-light.service && \
systemctl restart celestia-light.service && \
journalctl -fu celestia-light.service -o cat

#Bridge
systemctl daemon-reload && \
systemctl enable celestia-bridge.service && \
systemctl restart celestia-bridge.service && \
journalctl -fu celestia-bridge.service -o cat

#Full
systemctl daemon-reload && \
systemctl enable celestia-full.service && \
systemctl restart celestia-full.service && \
journalctl -fu celestia-full.service -o cat

Часть 3

Deploying sovereign Rollup using Rollkit and Run local chain

In this part of the guide, we will try to tell you how to rollup and start a local Celestia chain.

spoiler - easier than you think

First, let's set the variables and export them to .bash_profile

BLOCKCHAIN_NAME="NAME_HERE"
ADDR_PREFIX="PREFIX_HERE"

echo 'export BLOCKCHAIN_NAME='${BLOCKCHAIN_NAME} >> $HOME/.bash_profile
echo 'export ADDR_PREFIX='${ADDR_PREFIX} >> $HOME/.bash_profile
source $HOME/.bash_profile

Next, install Docker, a little later we will need it to start the local Celestia chain

curl -fsSL https://get.docker.com -o get-docker.sh sudo sh get-docker.sh

After installing Docker, we start the local chain with a script

docker run --platform linux/amd64 -p 26650:26657 -p 26659:26659 ghcr.io/rollkit/local-celestia-devnet:v0.9.1

Check if it works with a regular request

If everything is ok, it will output this response: {"denom":"utia","amount":"999995000000000"}

curl -X GET http://0.0.0.0:26659/balance

After the blockchain is launched, we open a separate session in our terminal and go there

All this can be done through the screen software, but since the guide for this Rollup is not very long, we will do without it, if you are more comfortable working with screen, everything is in your hands ;)

Let's now deal with such a thing as the Ignite CLI:

Ignite CLI is an easy-to-use CLI tool for creating and maintaining application-specific sovereign blockchains. Blockchains built with the Ignite CLI use the Cosmos SDK and Tendermint.

If you want to get to know this software better, welcome here

Next we need to install the Ignite CLI

curl https://get.ignite.com/cli! | bash

We check that everything is OK, and at the same time the version

ignite version

Next, we set the name of our blockchain and the address prefix

Next, we will show some part with screenshots, so that there are no questions

cd $HOME ignite scaffold chain $BLOCKCHAIN_NAME --address-prefix $ADDR_PREFIX

The output should go something like this

To further understand what we are doing, we need to tell you what Rollkit is, as usual concisely, if you are interested - read here

Rollkit - is a framework for Rollup that gives developers the freedom to deploy rollups across the entire modular stack, opening up new opportunities for rapid experimentation and innovation.

Next, go to the newly created directory

In our case, this is mms-team

cd $BLOCKCHAIN_NAME

Now we need to replace various Tendermint modules with Rollkit

go mod edit -replace github.com/cosmos/cosmos-sdk=github.com/rollkit/cosmos-sdk@v0.46.7-rollkit-v0.7.3-no-fraud-proofs go mod edit -replace github.com/tendermint/tendermint=github.com/celestiaorg/tendermint@v0.34.22-0.20221202214355-3605c597500d
go mod tidy
go mod download

Downloading the script that will launch our blockchain

wget https://raw.githubusercontent.com/rollkit/docs/main/docs/scripts/gm/init-local.sh

Add variables and export to .bash_profile

Let's add a little explanation
DENOM - this is the name of your coin
BIN_FILE - this is the name of your binary file, which will be generated during the script, to find out the name of your binary file, you just need to add the letter "d" to your BLOCKCHAIN_NAME, in our case it will be mms-teamd

VALIDATOR_NAME=YOUR_VAL_NAME_HERE
CHAIN_ID=YOUR_CHAIN_ID_HERE
KEY_NAME=YOUR_WALLET_NAME_HERE KEY_2_NAME=YOUR_SECOND_WALLET_NAME_HERE DENOM=YOUR_DENOM_HERE
BIN_FILE=YOUR_BLOCKCHAIN_NAMEd

echo 'export VALIDATOR_NAME='${VALIDATOR_NAME} >> $HOME/.bash_profile echo 'export CHAIN_ID='${CHAIN_ID} >> $HOME/.bash_profile
echo 'export KEY_NAME='${KEY_NAME} >> $HOME/.bash_profile
echo 'export KEY_2_NAME='${KEY_2_NAME} >> $HOME/.bash_profile
echo 'export DENOM='${DENOM} >> $HOME/.bash_profile
echo 'export BIN_FILE='${BIN_FILE} >> $HOME/.bash_profile
source $HOME/.bash_profile

For us it looks like this

Editing it for our variables

sed -i.bak -e "s/^VALIDATOR_NAME*=.*/VALIDATOR_NAME=$VALIDATOR_NAME/" $HOME/mms-team/init-local.sh sed -i.bak -e "s/^CHAIN_ID*=.*/CHAIN_ID=$CHAIN_ID/" $HOME/mms-team/init-local.sh sed -i.bak -e "s/^KEY_NAME*=.*/KEY_NAME=$KEY_NAME/" $HOME/mms-team/init-local.sh sed -i.bak -e "s/^KEY_2_NAME*=.*/KEY_2_NAME=$KEY_2_NAME/" $HOME/mms-team/init-local.sh sed -i.bak -e "9,10 s/stake/$DENOM/" $HOME/mms-team/init-local.sh sed -i.bak -e "s/^gmd/$BIN_FILE/" $HOME/mms-team/init-local.sh

Run the script

bash init-local.sh

It will end in an error, but we have generated our working directory and now we can completely change our denom, in a ready-made genesis

Пример ошибки

Our new working directory will be named the same as our BLOCKCHAIN_NAME, except that it will start with a dot ".mms-team/"

Add a variable for convenience and export to .bash_profile

WORK_DIRECTORY=.$BLOCKCHAIN_NAME

echo 'export WORK_DIRECTORY='${WORK_DIRECTORY} >> $HOME/.bash_profile
source $HOME/.bash_profile

With the command we change denom "stake", to the desired

sed -i.bak -e "s/stake/$DENOM/" $HOME/$WORK_DIRECTORY/config/genesis.json

Next, run the script again

bash init-local.sh

During the execution of the script, some errors will occur, the script will also ask us about performing some actions, everywhere we answer "n"

Example of errors

We launched our own blockchain, with our own variables

Example of chain start

In order not to invent anything with service files or with screen, we go to a separate terminal session

Now your personal Rollup is at your disposal, on the local Celestia chain

You can do whatever you want, test different things that you were afraid of before in various dunets / testnets / mainnets, everything works exactly the same as in the most ordinary spacefork

Just, for example, let's see what kind of wallets we have, make sure that the prefix that we set has really changed, and also see the balance and the list of validators

#Look at wallets
$BIN_FILE keys list --keyring-backend test

#See the balance of one of the wallets
$BIN_FILE q bank YOUR_ADDR_HERE

An example of what it looks like for us

In general, here, you can make all your wildest fantasies come true.

Stopping the local Celestia chain and stopping our Rollup

Next, we need to stop the networks that we launched, for this we go to the tab with our Rollup and press the key combination "ctrl + c", after which it will stop

Stopping and Removing the Celestia Local Chain Container and Stopping Rollup

To stop the Rollup that we launched, for this we go to the tab with our Rollup and press the key combination "ctrl + c", after which it will stop

Checking active containers with the command

docker ps -a

It will look like this:

Example of a working container

В колонке "Container ID", соответственно мы видим наш id контейнера, копируем его. Что бы остановить и удалить его, пишем следующие команды:

docker stop YOUR_CONTAINER_ID && \ docker rm YOUR_CONTAINER_ID

Part 3.1

Setting up the text module

Now that we have learned how to run our blockchain and the local Celestia chain, we will make it so that an additional command is added to our binary file, with the output of some text.
First we need to launch Celestia Light node, the installation process is described in Part 2
Create a query, answer "y" to a question from Ignite

cd $HOME/$BLOCKCHAIN_NAME/ ignite scaffold query $BLOCKCHAIN_NAME --response text

Further, in order not to produce even more variables, which are already enough, I will simply indicate where, what and how to change, with examples, in order to get to the desired file

We follow this path, it will be a little different for you, as well as the final file name, in fact, the name of your blockchain will be everywhere here. Our path looks like this:

nano x/mmsteam/keeper/query_mms_team.go For those who don't know, double tapping the "tab" button shows you what's in the directory, in this case it becomes much easier to search, use this

nano x/YOUR_CATALOG/keeper/query_YOUR_FILENAME.go

When you have opened the desired file, there we need to add our text, at the very bottom

We add this text in curly braces (you will have them empty), everything in quotes, you can safely change at your discretion, we will write:

Text: "Join us https://t.me/mmsnodes Peace to all'

Text: "YOUR_TEXT_HERE"

Function example

Save changes

We are downloading a new script to launch Rollup, only this time we will no longer launch the local Celestia chain, we will communicate with the real test chain using the LIght Node, the installation of which we described above

wget https://raw.githubusercontent.com/rollkit/docs/main/docs/scripts/gm/init-testnet.sh

Modifying the script for our variables

sed -i.bak -e "s/^VALIDATOR_NAME*=.*/VALIDATOR_NAME=$VALIDATOR_NAME/" $HOME/mms-team/init-testnet.sh
sed -i.bak -e "s/^CHAIN_ID*=.*/CHAIN_ID=$CHAIN_ID/" $HOME/mms-team/init-testnet.sh
sed -i.bak -e "s/^KEY_NAME*=.*/KEY_NAME=$KEY_NAME/" $HOME/mms-team/init-testnet.sh
sed -i.bak -e "s/stake/$DENOM/" $HOME/mms-team/init-testnet.sh
sed -i.bak -e "s/^gmd/$BIN_FILE/" $HOME/mms-team/init-testnet.sh

Delete the previous binary and working directory

rm -r $HOME/go/bin/$BIN_FILE && \
rm -rf $HOME/$WORK_DIRECTORY

We go to our directory, from where we build the binary and run our converted script

cd $HOME/$BLOCKCHAIN_NAME && \
bash init-testnet.sh

Again we get the "denom" error, like last time, we change our genesis

sed -i.bak -e "s/stake/$DENOM/" $HOME/$WORK_DIRECTORY/config/genesis.json

Run the script again and answer "n" everywhere

bash init-testnet.sh

We observe a successfully launched blockchain, using Rollkit, but this time with access to the Internet, and not via a local network

An example of a successful Rollup launch

And so, we have very little left, it remains to compose and give the last command that we created

Our command looks like this
$BIN_FILE q mmsteam mms-team
Let's explain, for each word in the command:
BIN_FILE - a variable with a binary file
q - a standard cosmos module for requests
mmsteam - our created text request module
mms-team - the request itself

$BIN_FILE q YOUR_QUERY_MODULE YOUR_QUERY

Our command's output

We learned how to create our own blockchain (Rollup), using the Ignite and Rollkit utilities, based on Celestia, we learned how to launch a local blockchain, as well as create our own, albeit simple (you have to start somewhere), modules for your blockchain.

Thank you very much for your attention and time
Our telegram channel on nodes - https://t.me/mmsnodes
Our telegram chat by nodes - https://t.me/mmsnodeschat
Our telegram channel on the Cosmos ecosystem - https://t.me/cosmochannel_mms

Sincerely, MMS_Team

How to set up the Quicksilver Node

2022-05-27T18:01:09.998Z

Hello everyone! Let's install the Quicksilver node and participate The Rhapsody testnet. Don't forget to play the "Bohemian Rhapsody" for inspiration.

Requirements for the node according to the documentation:
4 Cores (modern CPU's),
8GB RAM,
40GB of storage. Quicksilver is using statesync, so disk requirements will be low.

Always update your server first

sudo apt update && sudo apt upgrade -y

Install additional packages

sudo apt install make clang pkg-config libssl-dev build-essential git gcc chrony curl jq ncdu bsdmainutils htop net-tools lsof fail2ban wget -y

Go lang installation. Please check the version at the end.

cd $HOME
wget -O go1.18.1.linux-amd64.tar.gz https://golang.org/dl/go1.18.1.linux-amd64.tar.gz
rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.18.1.linux-amd64.tar.gz && rm go1.18.1.linux-amd64.tar.gz
echo 'export GOROOT=/usr/local/go' >> $HOME/.bash_profile
echo 'export GOPATH=$HOME/go' >> $HOME/.bash_profile
echo 'export GO111MODULE=on' >> $HOME/.bash_profile
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> $HOME/.bash_profile && . $HOME/.bash_profile
go version

Download and install the binary

git clone https://github.com/ingenuity-build/quicksilver.git --branch v0.3.0
cd quicksilver
make build

Move the binary to the correct folder

chmod +x ./build/quicksilverd && sudo mv ./build/quicksilverd /usr/local/bin/quicksilverd
cd $HOME

Set variables.
Change MONICKER to your name and set the WALLET NAME as well. Do not change the CHAIN name.

MONIKER="your_name"
CHAIN="rhapsody-5"
WALLET_NAME="your_name"

Save all variables in the .bash_profile

echo 'export MONIKER='${MONIKER} >> $HOME/.bash_profile
echo 'export CHAIN='${CHAIN} >> $HOME/.bash_profile
echo 'export WALLET_NAME='${WALLET_NAME} >> $HOME/.bash_profile
source $HOME/.bash_profile

Initialize the node

quicksilverd init $MONIKER --chain-id $CHAIN

Save the name of network, keyring backend and broadcast mode to the config file.

quicksilverd config chain-id $CHAIN
quicksilverd config keyring-backend test
quicksilver config broadcast-mode block

Download the genesis file

wget -qO $HOME/.quicksilverd/config/genesis.json "https://raw.githubusercontent.com/ingenuity-build/testnets/main/rhapsody/genesis.json"

Setting up pruning

pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.quicksilverd/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.quicksilverd/config/app.toml

Add seeds

seeds="dd3460ec11f78b4a7c4336f22a356fe00805ab64@seed.rhapsody-5.quicksilver.zone:26656"
sed -i.bak -e "s/^seeds *=.*/seeds = \"$seeds\"/" $HOME/.quicksilverd/config/config.toml

Create a service file

tee /etc/systemd/system/quicksilverd.service > /dev/null <<EOF
[unit]
Description=Quicksilver
After=network.target
[service]
Type=simple
User=$USER
ExecStart=$(which quicksilverd) start
Restart=on-failure
RestartSec=10
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF

And start the service

sudo systemctl daemon-reload
sudo systemctl enable quicksilverd
sudo systemctl restart quicksilverd

Let's check logs and wait for the node to start synchronizing

journalctl -u quicksilverd -f -o cat

Also, you can check synchronization status . If catching_up": false, your node is synchronized.

quicksilver status 2>&1 | jq .SyncInfo

After the synchronization, create your wallet. You will need to set a password. Do not change the name, we set it up earlier. Don't forget to save your mnemonic, password and wallet address.

quicksilverd keys add $WALLET_NAME

Link the variable with the wallet address

WALLET_ADDRESS=$(quicksilverd keys show $WALLET_NAME -a)

Add save this variable to the .bash_profile

echo 'export WALLET_ADDRESS='${WALLET_ADDRESS} >> $HOME/.bash_profile
source $HOME/.bash_profile

Now you need to receive funds from the faucet. Go to the discord channel #qck-tap and request tokens: $request wallet_number rhapsody

Check your balance:

quicksilverd query bank balances $WALLET_ADDRESS

If you already have tokens in your wallet, next step is creating validator. You can change amount for delegation.

quicksilverd tx staking create-validator \
--from=$WALLET_NAME \
--amount=5000000uqck \
--moniker=$MONIKER \
--chain-id=$CHAIN \
--commission-rate=0.1 \
--commission-max-rate=0.2 \
--commission-max-change-rate=0.1 \
--min-self-delegation=1 \
--pubkey=$(quicksilverd tendermint show-validator)

Link validator variable with the address.

VALOPER=$(quicksilverd keys show $WALLET_ADDRESS --bech val -a)

Аdd this variable to the .bash_profile

echo 'export VALOPER='${VALOPER} >> $HOME/.bash_profile
source $HOME/.bash_profile

Check the status

quicksilverd query staking validator $VALOPER

Delegate more to your validator. Check your balance and change the amount if needed.

quicksilverd tx staking delegate $VALOPER 1000000uqck --from $WALLET_NAME --chain-id $CHAIN

If you are JAILED, don't worry. This is the way back:

quicksilverd tx slashing unjail --from $WALLET_NAME --chain-id $CHAIN

Post in the discord proofs that you set up a validator and request the special role. Wait for announcements and participate in community discussions.

Thank you! Have a great day ahead!

Sincerely, MMS_Team

How to set up the SEI node

2022-05-27T18:00:31.817Z

Hello everyone. Let’s install the Sei node and join testate together.

More details about the project can be found on the official website.

Requirements for the node according to the documentation:
4 Cores (modern CPU's),
32GB RAM,
1TB of storage (SSD or NVME), but for the start standard configuration for cosmos is enough (4/8/200). Later on you will understand if you wish to stay connected and switch to required configurations.

As always, you need to update your server first

sudo apt update && sudo apt upgrade -y

Install additional packages

sudo apt install make clang pkg-config libssl-dev build-essential git gcc chrony curl jq ncdu bsdmainutils htop net-tools lsof fail2ban wget -y

Go lang installation. Please check the version at the end.

Download and install the binary

cd $HOME
git clone https://github.com/sei-protocol/sei-chain.git
cd sei chain
git checkout 1.0.0beta
go build -o build/seid ./cmd/sei-chaind

Move the binary to the correct folder

chmod +x ./build/seid && sudo mv ./build/seid /usr/local/bin/seid
cd $HOME

Set variables.
Change MONICKER to your preferred name and set the WALLET NAME as well. Do not change the CHAIN name.

MONIKER="your_name"
CHAIN="sei-testnet-1"
WALLET_NAME="your_name"

Save all variables to the .bash_profile

echo 'export MONIKER='${MONIKER} >> $HOME/.bash_profile
echo 'export CHAIN='${CHAIN} >> $HOME/.bash_profile
echo 'export WALLET_NAME='${WALLET_NAME} >> $HOME/.bash_profile
source $HOME/.bash_profile

Initialize the node

seid init $MONIKER --chain-id $CHAIN

Download genesis file and address book

wget -qO $HOME/.sei-chain/config/genesis.json "https://raw.githubusercontent.com/sei-protocol/testnet/master/sei-testnet-1/genesis.json"
wget -qO $HOME/.sei-chain/config/addrbook.json "https://raw.githubusercontent.com/sei-protocol/testnet/master/sei-testnet-1/addrbook.json"

Save the network name and keyring backend file to config.

seid config chain-id $CHAIN
seid config keyring-backend file

Setting up pruning

pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.sei-chain/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.sei-chain/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.sei-chain/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.sei-chain/config/app.toml

Add peers

PEERS="27aab76f983cd7c6558f1dfc50b919daaef14555@3.22.112.181:26656,39c4bcaded0d1d886f2788ae955f1939406f3e7d@65.108.198.54:26696,2f2804434afda302c86eb89eca27503e49a8a260@65.21.131.215:26696,6f71bcbe347069fc4df9b607f6b843226e8deb71@95.217.221.201:26656,2f047e234cb8b99fe8b9fee0059a5bc45042bc97@95.216.84.188:26656,3cd0ccddaba6c662fb5f4836456f448f13653587@212.125.21.178:45656 ,9db58dba3b6354177fb428caccf5167c616ad4a1@167.235.28.18:26656,38b4d78c7d6582fb170f6c19330a7e37e6964212@194.163.189.114:46656,3a0da1cda90931768a54af522639b3d2bbefcc3e@168.119.67.71:62136,54da741ec70bc68a613a7eac7a385a38b5127f0f@75.119.155.242:26657,67cd4f00052f81d4abbcc8013e300b302a3ffe6e@95.216.189.214:26656,5082637d2face9dd32c4ad7eff34d38df4244c9a@65.21.123.69:26642,4aaa57eb2ed8f839253193a893389338c081929b @80.82.215.233:26656,585727dac5df8f8662a8ff42052a9584a1f7ee95@165.22.25.77:26656"

sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.sei-chain/config/config.toml

Turn on prometheus

sed -i -e "s/prometheus=false/prometheus=true/" $HOME/.sei-chain/config/config.toml

Create a service file

tee /etc/systemd/system/seid.service > /dev/null <<EOF
[unit]
Description=SEI
After=network.target
[service]
Type=simple
User=$USER
ExecStart=$(which seid) start
Restart=on-failure
RestartSec=10
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF

Start the service

sudo systemctl daemon-reload
sudo systemctl enable seid
sudo systemctl restart seid

Check logs

journalctl -u seid -f -o cat

Also, you can check synchronization status . If catching_up": false, your node is synchronized.

seid status 2>&1 | jq .SyncInfo

If the node cannot connect to the peers, ask community in the Discord server to share available working peers.

After the synchronization, create your wallet. Do not change the name, we set it up earlier. Enter preferred password twice. Dont forget to save your mnemonic and wallet address.

seid keys add $WALLET_NAME

Create a variable for the wallet address (enter your password)

WALLET_ADDRESS=$(seid keys show $WALLET_NAME -a)

And add a variable to the .bash_profile

echo 'export WALLET_ADDRESS='${WALLET_ADDRESS} >> $HOME/.bash_profile
source $HOME/.bash_profile

You need to have tokens in your wallet to create a validator. At the moment there is a faucet channel in the discord. You need to fill up the form and wait for funds. Or you can use faucet HERE

Check your balance:

seid query bank balances $WALLET_ADDRESS

If you already have tokens in your wallet, next step is creating validator. You can change amount for delegation.

seid tx staking create-validator \
--amount 100000000usei \
--from $WALLET_NAME \
--commission-max-change-rate "0.01" \
--commission-max-rate "0.2" \
--commission-rate "0.07" \
--min-self-delegation "1" \
--pubkey $(seid tendermint show-validator) \
--moniker $MONIKER \
--chain-id $CHAIN

After creating validator, create a variable with its address (enter the password set earlier)

VALOPER=$(seid keys show $WALLET_ADDRESS --bech val -a)

Add this variable to the .bash_profile

echo 'export VALOPER='${VALOPER} >> $HOME/.bash_profile
source $HOME/.bash_profile

Check the status

seid query staking validator $VALOPER

Delegate more to your validator. Check balance and change the amount if needed.

seid tx staking delegate $VALOPER 1000000usei --from $WALLET_NAME --chain-id $CHAIN

If you are JAILED, dont worry. This is the way back:

seid tx slashing unjail --from $WALLET_NAME --chain-id $CHAIN

Post in the discord proofs that you set up a validator and request the special role. Wait for announcements and participate inn community discussions.

Thank you! Have a great day ahead!
Sincerely, MMS_Team

Installing the Cosmic Node

2022-04-25T18:28:39.682Z

Hello, today we will talk about installing the Cosmic node.

Stated requirements for the server today are as follows: 4vCPUs, 8GB RAM and 200GB Disk space

Do not forget that the start will be at 4-26-2022 17:45 UTC, if you installed it earlier, then restart the node. sudo systemctl restart cohod

After connecting to the server, through the terminal, update it:

sudo apt-get update && sudo apt upgrade -y

Next, install the necessary packages:

sudo apt install make clang pkg-config libssl-dev build-essential git gcc chrony curl jq ncdu bsdmainutils htop net-tools lsof fail2ban -y

Install GO version 1.18.1 and check the version after installation:

Download and move starport:

curl https://get.starport.network/starport | bash
sudo mv starport /usr/local/bin/

Download the executable file and install starport (installation time is about 5 minutes):

git clone https://github.com/cosmic-horizon/coho.git
cd ~/coho
starport chain build

We set the variables for our convenience (we leave COSMIC_CHAIN unchanged, enter our values into the rest of the variables):

COSMIC_CHAIN="darkenergy-1"
COSMIC_MONIKER="YOUR_MONIKER_NAME"
COSMIC_WALLET="YOUR_WALLET_NAME"

Adding variables to bash_profile

echo 'export COSMIC_CHAIN='${COSMIC_CHAIN} >> $HOME/.bash_profile
echo 'export COSMIC_MONIKER='${COSMIC_MONIKER} >> $HOME/.bash_profile
echo 'export COSMIC_WALLET='${COSMIC_WALLET} >> $HOME/.bash_profile
source $HOME/.bash_profile

We initialize the node:

cohod init $COSMIC_MONIKER --chain-id $COSMIC_CHAIN

Download Genesis:

wget -O $HOME/.coho/config/genesis.json https://raw.githubusercontent.com/cosmic-horizon/testnets/main/darkenergy-1/genesis.json

We set and prescribe seeds

seeds="a06e58e39d4a471d00d2e5d58233089c64fa5bb8@149.28.70.87:26657"
sed -i.bak -e "s/^seeds *=.*/seeds = \"$seeds\"/" $HOME/.coho/config/config.toml

We create a service

tee $HOME/cohod.service > /dev/null <<EOF
[Unit]
Description=coho
After=network.target
[Service]
Type=simple
User=$USER
ExecStart=$(which cohod) start
Restart=on-failure
RestartSec=10
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF

Move the service to the working folder

sudo mv $HOME/cohod.service /etc/systemd/system/

We start the service and look at the logs

sudo systemctl daemon-reload
sudo systemctl enable cohod
sudo systemctl restart cohod
journalctl -u cohod -f -o cat

Or we look at the status and wait until it is synchronized

curl -s localhost:26657/status

After you see "catching_up": false the node has been synced

Let's make a wallet! Don't forget to save the mnemonic!!! it will also ask you to enter a password to access the wallet. SAVE or REMEMBER (If the wallet already exists and you just need to restore it, use this command cohod keys add $COSMIC_WALLET --recover and enter the mnemonic)

cohod keys add $COSMIC_WALLET

Add the wallet address to the variable (for confirmation, you need the password entered earlier)

COSMIC_ADDR=$(cohod keys show $COSMIC_WALLET -a)

Adding variable to bash_profile

echo 'export COSMIC_ADDR='${COSMIC_ADDR} >> $HOME/.bash_profile
source $HOME/.bash_profile

Balance check

cohod query bank balances $COSMIC_ADDR

After synchronization, we create a validator, you can leave the commission or set your own (in the --amount line, enter the amount that we want to delegate with numbers, leave the letters ucoho), we also enter the previously entered password (do not forget that the wallet from which you will delegate must have funds):

cohod tx staking create-validator --yes \
--amount 1000000ucoho \
--moniker $COSMIC_MONIKER \
--commission-rate "0.10" \
--commission-max-rate "0.20" \
--commission-max-change-rate "0.01" \
--min-self-delegation "1" \
--pubkey "$(cohod tendermint show-validator)" \
--from $COSMIC_WALLET \
--chain-id $COSMIC_CHAIN

We write the address of the validator into a variable (the same password will need to be entered)

COSMIC_VALOPER=$(cohod keys show $COSMIC_WALLET --bech val -a)

Adding variable to bash_profile

echo 'export COSMIC_VALOPER='${COSMIC_VALOPER} >> $HOME/.bash_profile
source $HOME/.bash_profile

Checking the status of the validator:

cohod query staking validator $COSMIC_VALOPER

Now how to delegate funds to the validator:

cohod tx staking delegate $COSMIC_VALOPER [delegation sum in digits (square brackets removed) ]ucoho --from $COSMIC_WALLET --chain-id $COSMIC_CHAIN

Well, if suddenly your node got into jail, then the output is:

cohod tx slashing unjail --from $COSMIC_WALLET --chain-id $COSMIC_CHAIN

Thank you very much for your attention and time

Sincerely, MMS_Team

Installing the DeFund Node

2022-04-22T19:32:44.625Z

Hello everyone, today we will talk about installing the DeFund node

At the time of writing, the project launched only Private Testnet, perhaps everyone will be admitted further.

UPD: 04/22/2022 - You can still join the closed testnet
Fill out the form:
https://docs.google.com/forms/d/e/1FAIpQLSfqw1F6cDCsEt1Qmn70oIp3tdvcPFvRyk9Nd4mFacelhzQFYA/viewform
Discord - https://discord.gg/5D4Mdetf

The characteristics of the server have not yet been announced, but most likely, like other projects in cosmos 4/8/200

First, install GO

cd $HOME

wget -O go1.17.1.linux-amd64.tar.gz https://golang.org/dl/go1.17.linux-amd64.tar.gz

rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.17.1.linux-amd64.tar.gz && rm go1.17.1.linux-amd64.tar.gz

echo 'export GOROOT=/usr/local/go' >> $HOME/.bash_profile

echo 'export GOPATH=$HOME/go' >> $HOME/.bash_profile

echo 'export GO111MODULE=on' >> $HOME/.bash_profile

echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> $HOME/.bash_profile && . $HOME/.bash_profile

Checking the version

go version

As always, we update the server and install the necessary packages.

sudo apt update && sudo apt upgrade -y
sudo apt install curl tar wget clang pkg-config libssl-dev jq build-essential bsdmainutils git make ncdu gcc git jq chrony liblz4-tool -y

Скачиваем и устанавливаем ноду

git clone https://github.com/defund-labs/defund
cd $HOME/defund
make install

We set the names of the variables for convenience, you can do without them (we leave DEFUND_CHAIN unchanged, enter our names in the rest)

DEFUND_CHAIN="defund-private-1"
DEFUND_MONIKER="YOUR_MONIKER_NAME"
DEFUND_WALLET="YOUR_WALLET_NAME"

We register everything in the .bash_profile

echo 'export DEFUND_CHAIN='${DEFUND_CHAIN} >> $HOME/.bash_profile
echo 'export DEFUND_MONIKER='${DEFUND_MONIKER} >> $HOME/.bash_profile
echo 'export DEFUND_WALLET='${DEFUND_WALLET} >> $HOME/.bash_profile
source $HOME/.bash_profile

Initialize the node

defundd init $DEFUND_MONIKER --chain-id=$DEFUND_CHAIN

Adding seeds and peers

seeds="1b3e596531dd8f36363b13339beed2364900e4c6@104.131.41.157:26656"

peers="111ba4e5ae97d5f294294ea6ca03c17506465ec5@208.68.39.221:26656,26c42b6c3e8940c5433a5601464c4b370ab32cb4@139.162.146.250:26656"

sed -i "s/^seeds *=.*/seeds = \"$seeds\"/;" $HOME/.defund/config/config.toml
sed -i "s/^persistent_peers *=.*/persistent_peers = \"$peers\"/;" $HOME/.defund/config/config.toml

Download the genesis file

wget -O $HOME/.defund/config/genesis.json https://raw.githubusercontent.com/schnetzlerjoe/defund/main/testnet/private/genesis.json

defundd tendermint unsafe-reset-all --home $HOME/.defund

We create a service

tee $HOME/defund.service > /dev/null <<EOF
[Unit]
Description=Defund
After=network.target
[Service]
Type=simple
User=$USER
ExecStart=$(which defundd) start
Restart=on-failure
LimitNOFILE=65535
[Install]
WantedBy=multi-user.target
EOF

sudo mv $HOME/defund.service /etc/systemd/system/

Restart system services and turn on our

sudo systemctl restart systemd-journald
sudo systemctl daemon-reload
sudo systemctl enable defund
sudo systemctl restart defund

We look at the logs

journalctl -u defund -f -o cat

Or we look at the status and wait until it is synchronized

curl -s localhost:26657/status

After you see "catching_up": false the node has been synced

Let's make a wallet! Don't forget to save the mnemonic!!! it will also ask you to enter a password to access the wallet SAVE or REMEMBER (If the wallet already exists and you just need to restore it, use this command defundd keys add $DEFUND_WALLET --recover and enter the mnemonic)

defundd keys add $DEFUND_WALLET

We add the wallet address to the variable for our convenience (for confirmation, we need the password entered earlier)

DEFUND_ADDR=$(defundd keys show $DEFUND_WALLET -a)

Add a variable to .bash_profile:

echo 'export DEFUND_ADDR='${DEFUND_ADDR} >> $HOME/.bash_profile

source $HOME/.bash_profile

Balance check:

defundd query bank balances $DEFUND_ADDR

After synchronization, we create a validator (in the --amount line, we write in numbers the amount that we want to delegate the letters ufetf unchanged) we also enter the previously entered password (do not forget that the wallet from which you will delegate must have funds):

defundd tx staking create-validator \
--amount=25000000ufetf \
--pubkey=$(defundd tendermint show-validator) \
--moniker=$DEFUND_MONIKER \
--chain-id=defund-private-1 \
--commission-rate="0.10" \
--commission-max-rate="0.20" \
--commission-max-change-rate="0.01" \
--min-self-delegation="1" \
--from=$DEFUND_WALLET

We write the address of the validator into a variable (the same password will need to be entered)

DEFUND_VALOPER=$(defundd keys show $DEFUND_WALLET --bech val -a)

Add a variable to .bash_profile:

echo 'export DEFUND_VALOPER='${DEFUND_VALOPER} >> $HOME/.bash_profile
source $HOME/.bash_profile

Checking the status of the validator:

defundd query staking validator $DEFUND_VALOPER

Now how to delegate funds to the validator: (instead of values in brackets [ ] we insert our data, (remove parentheses) or variables if specified)

defundd tx staking delegate [VALOPER_ADDRESS] [STAKE_AMOUNT]ufetf --from [your-key-name] --chain-id defund-private-1

Well, if suddenly your node got into jail, then the output is: (instead of values in brackets [ ] we insert our data, (remove parentheses) or variables if specified)

defundd tx slashing unjail --from [your-key-name] --chain-id defund-private-1

Thank you very much for your attention and time

Sincerely, MMS_Team

Installing a STARKNET node

2022-04-09T13:26:17.963Z

Hello, here we will talk about installing the STARKNET node,

This guide was created based on the team's guide ПОТОК (https://teletype.in/@potokcrypto/starknet_node) and instructions from GitHub

This guide will only provide technical information on installing and checking the node, information about the STARKNET project can be found in the team guide ПОТОК

First of all, we need a server with Ubuntu 20.04 OS, as they assure the node is very undemanding and the minimum server configuration is enough 2 processor cores, 2 gigabytes of RAM, it is recommended to take 100 gigabytes of disk space just in case.

So we have a server, we connect to it through the terminal (you can use whichever is convenient for you).

Update server

sudo apt update && sudo apt upgrade -y

Upon completion of the process, install the necessary packages:

sudo apt install curl git python3-pip build-essential libssl-dev libffi-dev python3-dev libgmp-dev pkg-config -y

pip3 install fastecdsa

After install packages, we install Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

When script will request choice we choose (default)

Next we update Rust:

sudo apt install cargo -y

source $HOME/.cargo/env

rustup update stable

After execution last line will be look like this:

stable-x86_64-unknown-linux-gnu unchanged — rustc 1.59.0 (9d1b2106e 23.02.2022)

version 1.59.0 actual at the time of writing, for the node need not less 1.58.0

For the next step we clone repository from the github:

git clone --branch v0.1.11-alpha https://github.com/eqlabs/pathfinder.git

After we create a virtual environment:

sudo apt install python3.8-venv

cd pathfinder/py
python3 -m venv .venv
source .venv/bin/activate

PIP_REQUIRE_VIRTUALENV=true pip install --upgrade pip

PIP_REQUIRE_VIRTUALENV=true pip install -r requirements-dev.txt

Once everything is installed, you need to check that everything is fine, for this we enter the command:

pytest

After the test is complited you should see this:

If all seems good, we building the node

cargo build --release --bin pathfinder

Building takes about 10 minutes, after the end we need to create an account on Alchemy.com

To do this, click on the link in the upper right corner "Login"

After that, in the window that opens, click "Singup", log in with a Google account, or enter data and register

After that, a confirmation email will be sent to the specified email

We check the mail, in the letter we press the confirmation button, follow the link, and in the window that opens, press the "Get Started" button

Next, fill in the data and click "Create App" in the "Team Name" field, write your name or team name, in the "App Name" field, write what your node will be called (only for your convenience).

Then select a tariff plan (default is FREE), and click "Continue"

It will ask you to enter payment data, we refuse this by clicking "Skip for now"

Next, he will offer to tweet for a reward, at your discretion, we click "Skip for now"

And now we are almost at the goal in the new window, click "Continue"

But it wasn’t there, we are asked to indicate how you can contact in messengers and so on, if you wish, you can enter, or you can click "Let`s Go" and we are at the goal.

In the window that opens, we are interested in the field "Api Key"

We copy the data from this field, they will be needed to launch the node

We make a service file and launch the node (frase API_KEY - replace with your generated key , upd most importantly, do not remove the closing quote)

sudo tee /etc/systemd/system/starknetd.service > /dev/null <<EOF
[Unit]
Description=StarkNet
After=network.target
[Service]
Type=simple
User=root
WorkingDirectory=/root/pathfinder/py
ExecStart=/bin/bash -c 'source /root/pathfinder/py/.venv/bin/activate && /root/.cargo/bin/cargo run --release --bin pathfinder -- --ethereum.url https://eth-mainnet.alchemyapi.io/v2/API_KEY'
Restart=always
RestartSec=10
Environment=RUST_BACKTRACE=1
[Install]
WantedBy=multi-user.target
EOF

Next, launch service:

sudo systemctl daemon-reload
sudo systemctl enable starknetd
sudo systemctl start starknetd
journalctl -u starknetd -f -o cat

After that, we admire the ongoing synchronization, at the time of writing there were 1500 blocks. Then we return to the site and click on our APP

In the window that opens, we look, if numbers have gone then everything is fine and your node is exchanging data.

Further in the official Discord in the #🛰-pathfinder-full-node thread, we brag that we launched the node and it works.

After that, it remains only to monitor the performance of the node, the news and wait.

Addendum related to some questions: when you are connected to the server again, after closing the terminal, to see the synchronization status, enter the command

journalctl -u starknetd -f -o cat

Pathfinder has been updated to v0.1.11-alpha, everything has been fixed in the guide for a new installation, to update, do the following

sudo systemctl stop starknetd

cd pathfinder
git fetch
git checkout v0.1.11-alpha
cargo build --release --bin pathfinder
cd py
source .venv/bin/activate
PIP_REQUIRE_VIRTUALENV=true pip install --upgrade pip
PIP_REQUIRE_VIRTUALENV=true pip install -r requirements-dev.txt

And restart the service

sudo systemctl start starknetd

To see the synchronization status, enter the command

journalctl -u starknetd -f -o cat

Thank you for your time.

MMS_Team

Installing a KYVE node

2022-04-09T13:23:21.822Z

Good afternoon, today we will talk about installing a KYVE node

We will assume that you already have a server, if not, you can read other guides about it

After connecting to the server, through the terminal, update it:

sudo apt update && sudo apt upgrade -y

After that install curl :

apt install wget tar curl jq -y

Next, download and unpack the archive:

wget https://github.com/KYVENetwork/chain/releases/download/v0.0.1/chain_linux_amd64.tar.gz
tar -xvzf chain_linux_amd64.tar.gz
rm chain_linux_amd64.tar.gz
chmod +x chaind
mv chaind /usr/local/bin/kyved

After that, we set the names of the variables (Leave KYVE_CHAIN unchanged, enter your names in the rest)

KYVE_CHAIN="korellia"
KYVE_MONIKER="YOUR_MONIKER_NAME"
KYVE_WALLET="YOUR_WALLET_NAME"

Add variables to .bash_profile:

echo 'export KYVE_CHAIN='${KYVE_CHAIN} >> $HOME/.bash_profileecho 'export KYVE_MONIKER='${KYVE_MONIKER} >> $HOME/.bash_profileecho 'export KYVE_WALLET='${KYVE_WALLET} >> $HOME/.bash_profilesource $HOME/.bash_profile

We enter the command to initialize:

kyved init $KYVE_MONIKER --chain-id $KYVE_CHAIN

Download and copy the genesis file:

wget https://github.com/KYVENetwork/chain/releases/download/v0.0.1/genesis.json

mv genesis.json ~/.kyve/config/genesis.json

Installing seeds:

seeds="e56574f922ff41c68b80700266dfc9e01ecae383@18.156.198.41:26656,e56574f922ff41c68b80700266dfc9e01ecae383@3.73.27.185:26656"
PEERS="fd5d98a69998017c10ef9f4f08254d222478aa8b@195.2.85.56:26656"
sed -i.bak -e "s/^seeds *=.*/seeds = \"$seeds\"/; s/^persistent_peers *=.*/persistent_peers = \"$PEERS\"/" $HOME/.kyve/config/config.toml

Let's make a wallet! Don't forget to save the mnemonic!!! it will also ask you to enter a password to access the wallet SAVE or REMEMBER (If you already have a wallet and you just need to restore it, use this command kyved keys add $KYVE_WALLET --recover and enter the mnemonic)

kyved keys add $KYVE_WALLET

We add the wallet address to the variable for our convenience (for confirmation, we need the password entered earlier)

KYVE_ADDR=$(kyved keys show $KYVE_WALLET -a)

Add a variable to .bash_profile:

echo 'export KYVE_ADDR='${KYVE_ADDR} >> $HOME/.bash_profilesource $HOME/.bash_profile

Create a service file:

tee $HOME/kyved.service > /dev/null <<EOF[Unit]Description=kyveAfter=network.target[Service]Type=simpleUser=$USERExecStart=$(which kyved) startRestart=on-failureRestartSec=10LimitNOFILE=65535[Install]WantedBy=multi-user.targetEOF

Move the service file to the working folder:

sudo mv $HOME/kyved.service /etc/systemd/system/

Run service file:

sudo systemctl daemon-reload
sudo systemctl enable kyved
sudo systemctl restart kyved

Checking the logs:

journalctl -u kyved -f -o cat

Or we look at the status and wait until the node is synchronized:

curl -s localhost:26657/status

After you see "catching_up": false the node has been synced

Next, you need to update the node to switch to the next chain

wget https://github.com/KYVENetwork/chain/releases/download/v0.1.0/chain_linux_amd64.tar.gz
tar -xvzf chain_linux_amd64.tar.gz
rm chain_linux_amd64.tar.gz
sudo systemctl stop kyved
chmod +x chaind
mv chaind /usr/local/bin/kyved
sudo systemctl start kyved

Checking the logs:

journalctl -u kyved -f -o cat

Or we look at the status and wait until the node is synchronized:

curl -s localhost:26657/status

After you see "catching_up": false the node has been synced

Switching back to the next chain

wget https://github.com/KYVENetwork/chain/releases/download/v0.2.0/chain_linux_amd64.tar.gz
tar -xvzf chain_linux_amd64.tar.gz
rm chain_linux_amd64.tar.gz
sudo systemctl stop kyved
chmod +x chaind
mv chaind /usr/local/bin/kyved
sudo systemctl start kyved

Checking the logs:

journalctl -u kyved -f -o cat

Or we look at the status and wait until the node is synchronized:

curl -s localhost:26657/status

After you see "catching_up": false the node has been synced

Switching back to the next chain

wget https://github.com/KYVENetwork/chain/releases/download/v0.3.0/chain_linux_amd64.tar.gz
tar -xvzf chain_linux_amd64.tar.gz
rm chain_linux_amd64.tar.gz
sudo systemctl stop kyved
chmod +x chaind
mv chaind /usr/local/bin/kyved
sudo systemctl start kyved

Balance check:

kyved query bank balances $KYVE_ADDR

After synchronization, we create a validator (in the --amount line, we write in numbers the amount that we want to delegate the letters tkyve do not touch), we also enter the previously entered password (do not forget that the wallet from which you will delegate should have funds):

kyved tx staking create-validator --yes \ --amount 500000000000tkyve \ --moniker $KYVE_MONIKER \ --commission-rate "0.10" \ --commission-max-rate "0.20" \ --commission-max-change-rate "0.01" \ --min-self-delegation "1" \ --pubkey "$(kyved tendermint show-validator)" \ --from $KYVE_WALLET \ --chain-id korellia

We write the address of the validator into a variable (enter the password set earlier)

KYVE_VALOPER=$(kyved keys show $KYVE_WALLET --bech val -a)

Add a variable to .bash_profile:

echo 'export KYVE_VALOPER='${KYVE_VALOPER} >> $HOME/.bash_profilesource $HOME/.bash_profile

Checking the status of the validator:

kyved query staking validator $KYVE_VALOPER

View explorer in terminal:

How to delegate funds to the validator:

kyved tx staking delegate [VALOPER_ADDRESS] [STAKE_AMOUNT]tkyve --from [your-key-name] --chain-id korellia

Well, if suddenly your node got into jail, then the output is:

kyved tx slashing unjail --chain-id korellia --from [your-key-name]

Thank you very much for your attention and time

Sincerely, MMS_Team