# Welcome

AnyValid - Professional Proof-of-Stake Networks Validation Services

We have been providing our staking services since 2020. We have participated in more than 40 projects at the development and testing stages, more than 10 projects at the mainnet stage, several useful developments for the community of various projects: [Umee Faucet](https://umee.anyvalid.com), [Tgrade Governance Alert Bot](https://discord.com/channels/844486286445903872/1015345638159945752), [Validator Status Bot for LikeCoin](https://discord.com/channels/763001015712350231/885853680589471796).

Hundreds of different stakers trust us with over $1.5 million. Join us [HERE](https://anyvalid.com/#Stake)

### AnyValid - where earnings and security converge


# Umee

Cross the Defi Waves

The most programmable, safety-first, autonomous lending algorithm built as a blockchain. Umee is reshaping the global debt markets in Web3.

Umee enables the development of the next generation of lending markets through a combination of leverage focused DeFi applications and interest rate primitives.

Umee is a base layer blockchain for permissionless, autonomous debt financing markets. Umee is built using the Cosmos SDK and powered by Tendermint Consensus, Inter-blockchain Communication Protocol (IBC), and a self sovereign validator network.

Umee offers the most programmable suite of lending-specific algorithms and base layer blockchain modules to enable the maximum safety guarantees customized for each asset’s individual risk profile.

#### Project website:

{% embed url="<https://umee.cc>" %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop umeed
umeed tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://umee-rpc.anyvalid.com:26647"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="f827a823a54d1deb02324362c4b81f275e596621@88.99.140.176:26646"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.umee/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.umee/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart umeed
sudo journalctl -u umeed -f -o cat
```


# RPC Endpoint

RPC (port 26647) - `https://umee-rpc.anyvalid.com`

gRPC - `http://umee-grpc.anyvalid.com`

API - `https://umee-api.anyvalid.com`


# Faucet

Umee Faucet by AnyValid

### You can drip from the faucet and get 0.1umee token for free

#### Follow the link to find Faucet:

{% embed url="<https://umee.anyvalid.com>" %}


# Humans

The Blockchain of the AIs

HUMANS is creating an all-in-one platform for AI-based creation and governance at scale, beginning an initial focus on synthetic media. Through its creative studio and token based ownership and accountability system, HUMANS is designed to ensure contributions are fairly rewarded and that every AI is kept honest over the long term.

HUMANS is a next generation blockchain platform that brings together an ecosystem of stakeholders around the use of AI to create at scale. It combines a library of AI tools into a creative studio suite where users will be able to pick and choose as they bring their ideas to life. Individuals are empowered to create and own their digital likenesses, which may be used by themselves and others in the creation of any number of digital assets. The synthetic media, AI apps, and other digital assets utilize blockchain technology to generate Non-Fungible Tokens (NFTs) as a way of creating transparency, accountability, and long term governance.

#### Project website:

{% embed url="<https://humans.ai>" %}

#### Project Discord:

{% embed url="<https://discord.gg/humansdotai>" %}


# Setup Guide

Follow the guide to set up your Humans Mainnet node

#### **Step 1: Update and install necessary packages**

```bash
sudo apt update && sudo apt upgrade --yes && \
sudo apt install git build-essential ufw curl jq snapd screen ncdu nano fuse ufw --yes
```

#### **Step 2: Install Go**

```bash
sudo snap install go --classic && \
echo 'export GOPATH="$HOME/go"' >> ~/.profile && \
echo 'export GOBIN="$GOPATH/bin"' >> ~/.profile && \
echo 'export PATH="$GOBIN:$PATH"' >> ~/.profile && \
source ~/.profile && \
go version
```

#### Step 3: Clone repo and compile binary (you can find releases here: [click](https://github.com/humansdotai/humans/releases))

```bash
git clone https://github.com/humansdotai/humans
cd humans
git checkout v$(curl -s https://humans-rpc.anyvalid.com/abci_info | jq -r .result[].version)
make install
```

#### Step 4: Init your keys and download genesis file

```bash
humansd init <moniker> --chain-id humans_1089-1
humansd keys add <keyname>
wget https://anyvalid.com/humans/genesis.json -O $HOME/.humansd/config/genesis.json
wget https://anyvalid.com/humans/addrbook.json -O $HOME/.humansd/config/addrbook.json
```

#### Step 5: Set up gas\_price / persistent\_peers / pruning

```bash
sed -i "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.1aheart\"/;" $HOME/.humansd/config/app.toml
sed -E -i 's/persistent_peers = \".*\"/persistent_peers = \"0a63421f67d02e7fb823ea6d6ceb8acf758df24d@142.132.226.137:26656,4a319eead699418e974e8eed47c2de6332c3f825@167.235.255.9:26656,6918efd409684d64694cac485dbcc27dfeea4f38@49.12.240.203:26656\"/' $HOME/.humansd/config/config.toml
pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.humansd/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.humansd/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.humansd/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.humansd/config/app.toml
```

#### Step 6: Set up Humans service

```bash
sudo tee /etc/systemd/system/humansd.service > /dev/null <<EOF
[Unit]
Description=Humansd daemon
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/go/bin/humansd start
Restart=on-failure
RestartSec=3
LimitNOFILE=100000

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

#### Step 7: Enable Humans daemon

```bash
sudo systemctl enable humansd
sudo systemctl daemon-reload
```

### If you want to synchronize your node from the 0 block:

#### Start Humans service and watch logs

```bash
sudo systemctl restart humansd
sudo journalctl -u humansd -f -o cat
```

Or you can quickly synchronize your node through State Sync:

{% content-ref url="/pages/0fFy5FUITHBPydwI7bhX" %}
[State Sync Guide](/mainnets/humans/state-sync-guide)
{% endcontent-ref %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop humansd
humansd tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://humans-rpc.anyvalid.com:26627"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="48e2576d3542b9362beb4112706f5667c3582078@88.99.140.176:26626"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.humansd/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.humansd/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart humansd
sudo journalctl -u humansd -f -o cat
```


# RPC Endpoint

### RPC - You can use our high-performance RPC (Port 26637):

`https://humans-rpc.anyvalid.com`

### API (swagger is on) (Port 1287):

`https://humans-rpc.anyvalid.com`

### gRPC (Port 9060):

`https://humans-rpc.anyvalid.com`


# Dymension

Home of the RollApps

Dymension is a home for easily deployable and lightning fast app-chains, called RollApps.

Easily deploy your own consensus-free blockchain and accrue more token value with greater security.

#### Project website:

{% embed url="<https://dymension.xyz>" %}


# Setup Guide

Follow the guide to set up your Dymension Mainnet node

#### **Step 1: Update and install necessary packages**

```bash
sudo apt update && sudo apt upgrade --yes && \
sudo apt install git build-essential ufw curl jq snapd screen ncdu nano fuse ufw --yes
```

#### **Step 2: Install Go**

```bash
sudo snap install go --classic && \
echo 'export GOPATH="$HOME/go"' >> ~/.profile && \
echo 'export GOBIN="$GOPATH/bin"' >> ~/.profile && \
echo 'export PATH="$GOBIN:$PATH"' >> ~/.profile && \
source ~/.profile && \
go version
```

#### Step 3: Clone repo and compile binary (you can find releases here: [click](https://github.com/confio/tgrade/tags))

```bash
git clone https://github.com/dymensionxyz/dymension
cd dymension
git checkout v$(curl -s https://dymension-rpc.anyvalid.com/abci_info | jq -r .result[].version)
make install
```

#### Step 4: Init your keys and download genesis file

```bash
dymd init <moniker> --chain-id dymension_1100-1
dymd keys add <keyname>
wget https://github.com/dymensionxyz/networks/raw/main/mainnet/dymension/genesis.json -O /root/.dymension/config/genesis.json
```

#### Step 5: Set up gas\_price / persistent\_peers / pruning

```bash
sed -i "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"20000000000adym\"/;" $HOME/.dymension/config/app.toml
sed -E -i 's/persistent_peers = \".*\"/persistent_peers = \"5f9ed4b975e0896b8ea862d29a45658e38b4f95d@88.99.140.176:26606\"/' $HOME/.dymension/config/config.toml
pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.dymension/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.dymension/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.dymension/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.dymension/config/app.toml
```

#### Step 6: Set up Dymension service

```bash
sudo tee /etc/systemd/system/dymd.service > /dev/null <<EOF
[Unit]
Description=Dymension daemon
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/go/bin/dymd start
Restart=on-failure
RestartSec=3
LimitNOFILE=100000

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

#### Step 7: Enable Dymension daemon

```bash
sudo systemctl enable dymd
sudo systemctl daemon-reload
```

### If you want to synchronize your node from the 0 block:

#### Start Dymension service and watch logs

```bash
sudo systemctl restart dymd
sudo journalctl -u dymd -f -o cat
```

Or you can quickly synchronize your node through State Sync:

{% content-ref url="/pages/O60Rh7bz2LJC2xzBax8P" %}
[State Sync Guide](/archive/tgrade/state-sync-guide)
{% endcontent-ref %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop dymd
dymd tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://dymension-rpc.anyvalid.com:26607"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="5f9ed4b975e0896b8ea862d29a45658e38b4f95d@88.99.140.176:26606"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.dymension/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.dymension/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart dymd
sudo journalctl -u dymd -f -o cat
```


# RPC Endpoint

RPC (port 26607) - `https://dymension-rpc.anyvalid.com`

gRPC - `http://dymension-grpc.anyvalid.com`

API - `https://dymension-api.anyvalid.com`


# Tgrade

A public, decentralised blockchain

The case for a public, decentralised, secure blockchain is strong. Public blockchains are resilient by design as they are run by a group of independent node operators who are aligned through a framework of incentives and punishments.

Tgrade is a chain that has been designed to support high value businesses in a very secure and decentralised model that is robust and safe.

#### Project website:

{% embed url="<https://tgrade.finance/>" %}


# Setup Guide

Follow the guide to set up your Tgrade Mainnet node

#### **Step 1: Update and install necessary packages**

```bash
sudo apt update && sudo apt upgrade --yes && \
sudo apt install git build-essential ufw curl jq snapd screen ncdu nano fuse ufw --yes
```

#### **Step 2: Install Go**

```bash
sudo snap install go --classic && \
echo 'export GOPATH="$HOME/go"' >> ~/.profile && \
echo 'export GOBIN="$GOPATH/bin"' >> ~/.profile && \
echo 'export PATH="$GOBIN:$PATH"' >> ~/.profile && \
source ~/.profile && \
go version
```

#### Step 3: Clone repo and compile binary (you can find releases here: [click](https://github.com/confio/tgrade/tags))

```bash
git clone https://github.com/confio/tgrade
cd tgrade
git checkout v$(curl -s https://tgrade-rpc.anyvalid.com/abci_info | jq -r .result[].version)
make install
```

#### Step 4: Init your keys and download genesis file

```bash
tgrade init <moniker> --chain-id tgrade-mainnet-1
tgrade keys add <keyname>
wget https://raw.githubusercontent.com/confio/tgrade-networks/main/mainnet-1/config/genesis.json -O /root/.tgrade/config/genesis.json
```

#### Step 5: Set up gas\_price / persistent\_peers / pruning

```bash
sed -i "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.05utgd\"/;" $HOME/.tgrade/config/app.toml
sed -E -i 's/persistent_peers = \".*\"/persistent_peers = \"0a63421f67d02e7fb823ea6d6ceb8acf758df24d@142.132.226.137:26656,4a319eead699418e974e8eed47c2de6332c3f825@167.235.255.9:26656,6918efd409684d64694cac485dbcc27dfeea4f38@49.12.240.203:26656\"/' $HOME/.tgrade/config/config.toml
pruning="custom"
pruning_keep_recent="100"
pruning_keep_every="0"
pruning_interval="10"
sed -i -e "s/^pruning *=.*/pruning = \"$pruning\"/" $HOME/.tgrade/config/app.toml
sed -i -e "s/^pruning-keep-recent *=.*/pruning-keep-recent = \"$pruning_keep_recent\"/" $HOME/.tgrade/config/app.toml
sed -i -e "s/^pruning-keep-every *=.*/pruning-keep-every = \"$pruning_keep_every\"/" $HOME/.tgrade/config/app.toml
sed -i -e "s/^pruning-interval *=.*/pruning-interval = \"$pruning_interval\"/" $HOME/.tgrade/config/app.toml
```

#### Step 6: Set up Tgrade service

```bash
sudo tee /etc/systemd/system/tgrade.service > /dev/null <<EOF
[Unit]
Description=Tgrade daemon
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/go/bin/tgrade start
Restart=on-failure
RestartSec=3
LimitNOFILE=100000

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

#### Step 7: Enable Tgrade daemon

```bash
sudo systemctl enable tgrade
sudo systemctl daemon-reload
```

### If you want to synchronize your node from the 0 block:

#### Start Tgrade service and watch logs

```bash
sudo systemctl restart tgrade
sudo journalctl -u tgrade -f -o cat
```

Or you can quickly synchronize your node through State Sync:

{% content-ref url="/pages/O60Rh7bz2LJC2xzBax8P" %}
[State Sync Guide](/archive/tgrade/state-sync-guide)
{% endcontent-ref %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop tgrade
tgrade tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://tgrade-rpc.anyvalid.com:26637"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="f7dd1c57e6aecbe415af69613a6966b06f8b21c9@88.99.140.176:26636"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.tgrade/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.tgrade/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart tgrade
sudo journalctl -u tgrade -f -o cat
```


# RPC Endpoint

RPC (port 26637) - `https://tgrade-rpc.anyvalid.com`

gRPC - `http://tgrade-grpc.anyvalid.com`

API - `https://tgrade-api.anyvalid.com`


# LikeCoin


# Setup Guide

Follow the guide to set up your LikeCoin Mainnet node

#### **Step 1: Update and install necessary packages**

```bash
sudo apt update && sudo apt upgrade --yes && \
sudo apt install git build-essential ufw curl jq snapd screen ncdu nano fuse ufw --yes
```

#### **Step 2: Install Go**

```bash
sudo snap install go --classic && \
echo 'export GOPATH="$HOME/go"' >> ~/.profile && \
echo 'export GOBIN="$GOPATH/bin"' >> ~/.profile && \
echo 'export PATH="$GOBIN:$PATH"' >> ~/.profile && \
source ~/.profile && \
go version
```

#### Step 3: Clone repo and compile binary (you can find releases here: [click](https://github.com/humansdotai/humans/releases))

```bash
git clone https://github.com/likecoin/likecoin-chain
cd likecoin-chain
git checkout v4.2.0
make install
```

#### Step 4: Init your keys and download genesis file

```bash
liked init <moniker>
liked keys add <keyname>
curl https://raw.githubusercontent.com/likecoin/mainnet/master/genesis.json > ~/.liked/config/genesis.json
```

#### Step 5: Set up minimum gas price

```bash
sed -i.bak -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"10000nanolike\"/;" ~/.liked/config/app.toml
```

#### Step 6: Set up pruning (optional)

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

#### Step 7: Set up LikeCoin service

```bash
sudo tee /etc/systemd/system/liked.service > /dev/null <<EOF
[Unit]
Description=LikeCoin daemon
After=network-online.target

[Service]
User=$USER
ExecStart=$HOME/go/bin/liked start
Restart=on-failure
RestartSec=3
LimitNOFILE=100000

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

#### Step 7: Enable LikeCoin daemon

```bash
sudo systemctl enable liked
sudo systemctl daemon-reload
```

### If you want to synchronize your node from the 0 block:

#### Start LikeCoin service and check logs

```bash
sudo systemctl restart liked
sudo journalctl -u liked -f -o cat
```

Or you can quickly synchronize your node through State Sync:

{% content-ref url="/pages/15Czh1Bp5sy6HmQ03F3z" %}
[State Sync Guide](/archive/likecoin/state-sync-guide)
{% endcontent-ref %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop liked
liked tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://likecoin-rpc.anyvalid.com:26597"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="6a86c1c7996e21db981032a49d55c2bc396830d9@88.99.140.176:26596"

echo $RECENT_HEIGHT $TRUST_HEIGHT $TRUST_HASH
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.liked/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.liked/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart liked
sudo journalctl -u liked -f -o cat
```


# RPC Endpoint

### RPC - You can use our high-performance RPC (Port 26597):

`https://likecoin-rpc.anyvalid.com`

### API (swagger is on) (Port 1257):

`https://likecoin-api.anyvalid.com`

### gRPC (Port 9030):

`https://likecoin-grpc.anyvalid.com`


# Firmachain

Expand your future a scalable blockchain network

Developed based on our proprietary blockchain technology, FIRMACHAIN’s mainnet strives to become the pioneer of the Web 3.0 era by offering a comprehensive blockchain platform where DiD, Wallet, NFTs, DApps and so much more can be developed.

FIRMACHAIN utilizes the Tendermint engine and Comos Inter-Blockchain Communication Protocol to provide optimal business scalability and usability.

#### Project website:

{% embed url="<https://firmachain.org>" %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop firmachaind
firmachaind tendermint unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://firmachain-rpc.anyvalid.com:26617"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="e1b6bf686b1da507a36eb982aebbf9a0a372d3af@5.9.87.205:26616"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.firmachain/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.firmachain/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart firmachaind
sudo journalctl -u firmachaind -f -o cat
```


# RPC Endpoint

RPC (port 26617) - `https://firmachain-rpc.anyvalid.com`

gRPC - `http://firmachain-grpc.anyvalid.com`

API - `https://firmachain-api.anyvalid.com`


# Nolus

Redefining Digital Asset Ownership

AssetMantle’s suite of products, which is focussed on NFT ecosystem, helps you up your game of digital asset ownership.

AssetMantle’s foundation is built using the best-in-class core blockchain principles, and optimized for the next evolution of NFT economy.

AssetMantle suite of products creates a distributed NFT Economy where users can create not only NFT collections but their own NFT marketplaces and storefronts.

This shopifying of NFT assets, leads to a distributed network of networks, with world state stored collectively in the AssetMantle chain.

#### Project website:

{% embed url="<https://assetmantle.one>" %}


# Snapshot Guide

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop nolusd
cp $HOME/.nolus/data/priv_validator_state.json $HOME/priv_validator_state.json
nolusd tendermint unsafe-reset-all --home $HOME/.nolus --keep-addr-book
```

#### Step 2: Download nolus data

```bash
wget http://nolus-rpc.anyvalid.com/nolus/data_nolus-rila.tar
tar -xf data_nolus-rila.tar -C $HOME/.nolus/data/
rm data_nolus-rila.tar
```

#### Step 3: Download nolus wasm directory

```bash
wget http://nolus-rpc.anyvalid.com/nolus/wasm_nolus-rila.tar
mkdir $HOME/.nolus/wasm/
tar -xf wasm_nolus-rila.tar -C $HOME/.nolus/wasm/
rm wasm_nolus-rila.tar
```

#### Step 4: Restore your `priv_validator_state.json` file

```bash
mv $HOME/priv_validator_state.json $HOME/.nolus/data/priv_validator_state.json
```

#### Step 5: Start service and open journal

```bash
sudo systemctl restart nolusd
sudo journalctl -u nolusd -f -o cat
```


# RPC Endpoint

### RPC - You can use our high-performance  RPC (Port 26617)

RPC - [`http://nolus-rpc.anyvalid.com:26617`](http://nolus-rpc.anyvalid.com:26617/)

gRPC - [`http://nolus-rpc.anyvalid.com:9050`](http://nolus-rpc.anyvalid.com:26617/)

API - [`http://nolus-rpc.anyvalid.com:1287`](http://nolus-rpc.anyvalid.com:26617/)


# AssetMantle

Redefining Digital Asset Ownership

AssetMantle’s suite of products, which is focussed on NFT ecosystem, helps you up your game of digital asset ownership.

AssetMantle’s foundation is built using the best-in-class core blockchain principles, and optimized for the next evolution of NFT economy.

AssetMantle suite of products creates a distributed NFT Economy where users can create not only NFT collections but their own NFT marketplaces and storefronts.

This shopifying of NFT assets, leads to a distributed network of networks, with world state stored collectively in the AssetMantle chain.

#### Project website:

{% embed url="<https://assetmantle.one>" %}


# Setup Guide

Follow the guide to set up your AssetMantle Mainnet node

#### Step 1: Update and install necessary packages

```bash
sudo apt update && sudo apt upgrade --yes && \
sudo apt install git build-essential ufw curl jq snapd screen ncdu nano fuse ufw --yes
```

#### Step 2: Install Go

```bash
sudo snap install go --classic && \
echo 'export GOPATH="$HOME/go"' >> ~/.profile && \
echo 'export GOBIN="$GOPATH/bin"' >> ~/.profile && \
echo 'export PATH="$GOBIN:$PATH"' >> ~/.profile && \
source ~/.profile && \
go version
```

#### Step 3: Clone the repository and compile binary

```bash
git clone https://github.com/AssetMantle/node.git
cd node
git checkout tags/v0.3.0
make install
```

#### Step 4: Init your keys and download genesis file

```bash
mantleNode init <moniker> --chain-id mantle-1
mantleNode keys add <keyname>
curl https://raw.githubusercontent.com/AssetMantle/genesisTransactions/main/mantle-1/final_genesis.json > $HOME/.mantleNode/config/genesis.json
```

#### Step 5: Set up AssetMantle system service

```bash
sudo tee /etc/systemd/system/assetmantle.service > /dev/null <<EOF
[Unit]
Description=AssetMantleNode Service
Requires=network-online.target
After=network-online.target

[Service]
User=root
Restart=on-failure
RestartSec=3
MemoryDenyWriteExecute=yes
LimitNOFILE=65535
ExecStart=/root/go/bin/mantleNode start --x-crisis-skip-assert-invariants

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

#### Step 6: Enable AssetMantle daemon

```bash
sudo systemctl daemon-reload
sudo systemctl enable assetmantle
```

### If you want to synchronize your node from the 0 block:

#### Start AssetMantle service and watch logs

```bash
sudo systemctl start assetmantle
journalctl -u assetmantle -f -o cat
```

Or you can quickly synchronize your node through State Sync:

{% content-ref url="/pages/MIH8aGteqWD3MCznqwYB" %}
[State Sync Guide](/archive/assetmantle/state-sync-guide)
{% endcontent-ref %}


# State Sync Guide

{% hint style="info" %}
State Sync allows to sync a node state by fetching a snapshot of the network state at a recent height, instead of fetching and replaying all historical blocks.
{% endhint %}

#### Step 1: Stop existing service and reset database

```bash
sudo systemctl stop assetmantle
assetmantle unsafe-reset-all --keep-addr-book
```

#### Step 2: Fill variables with data for State Sync

```bash
RPC="https://assetmantle-rpc.anyvalid.com:443"
RECENT_HEIGHT=$(curl -s $RPC/block | jq -r .result.block.header.height)
TRUST_HEIGHT=$((RECENT_HEIGHT - 1000))
TRUST_HASH=$(curl -s "$RPC/block?height=$TRUST_HEIGHT" | jq -r .result.block_id.hash)
PEER="aaab061b5526d7adea269ea35a759e9a541bd0ae@88.99.243.241:26656"
```

#### Step 3: Add variable values to config.toml

```bash
sed -i.bak -E "s|^(enable[[:space:]]+=[[:space:]]+).*$|\1true| ; \
s|^(rpc_servers[[:space:]]+=[[:space:]]+).*$|\1\"$RPC,$RPC\"| ; \
s|^(trust_height[[:space:]]+=[[:space:]]+).*$|\1$TRUST_HEIGHT| ; \
s|^(trust_hash[[:space:]]+=[[:space:]]+).*$|\1\"$TRUST_HASH\"|" $HOME/.mantleNode/config/config.toml
sed -i.bak -e "s/^persistent_peers *=.*/persistent_peers = \"$PEER\"/" $HOME/.mantleNode/config/config.toml
```

#### Step 4: Start service and open journal

```bash
sudo systemctl restart assetmantle
sudo journalctl -u assetmantle -f -o cat
```


# RPC Endpoint

### RPC - You can use our high-performance archive RPC (Port 443)

`https://assetmantle-rpc.anyvalid.com:443`

{% embed url="<https://assetmantle-rpc.anyvalid.com>" %}

API - `http://assetmantle-rpc.anyvalid.com:1317`

{% embed url="<http://assetmantle-rpc.anyvalid.com:1317>" %}


# Contacts