# Running a Node

### Install Prerequisites

{% hint style="success" %}
You can also check [this guide](https://aviaone.com/blockchains-service/andromeda-1-andromeda.html) that was created by one of our validators.
{% endhint %}

```bash
sudo apt-get update && sudo apt upgrade -y
sudo apt-get install make build-essential git jq chrony -y
```

```bash
sudo apt install gcc
```

### Increasing the default open files limit

This is to make sure that the nodes won't crash once the network grows larger and larger.

```bash
sudo su -c "echo 'fs.file-max = 65536' >> /etc/sysctl.conf"
sudo sysctl -p
```

### Installing Go 1.20.x

You can find GoLang 1.20.x from [here](https://go.dev/dl/).

### Updating Environment Variables 

```bash
cat <<'EOF' >>$HOME/.profile
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export GO111MODULE=on
export GOBIN=$HOME/go/bin
export PATH=$PATH:/usr/local/go/bin:$GOBIN
EOF
source $HOME/.profile
```

Next we need to clone the source repo:

```bash
git clone https://github.com/andromedaprotocol/andromedad.git
cd andromedad
make install
```

## Initialize the Config Files

```bash
andromedad init <MONIKER> --chain-id andromeda-1
andromedad config chain-id andromeda-1
```

Now, your node environment should be ready to go! In order to sync up to the network, a few more parameters must be changed to proper specifics for the network:

```bash
cd ~/.andromeda/config/
```

#### Create new keys, or import existing wallet with BEP32 mnenomic phrase:

```bash
andromedad keys add <KEY_NAME> --keyring-backend os
```

To recover existing wallet:

```bash
andromedad keys add <KEY_NAME> --keyring-backend os --recover
```

### \`gentx\` Command

To generate your validators transaction (gentx) use the following command:

```
andromedad genesis gentx <WALLET> 100000000000uandr --chain-id andromeda-1
```

Then submit a pull request to the `mainnet` repo where you found the genesis.json

### Create environment Variable:

```bash
MY_VALIDATOR_ADDRESS=$(andromedad keys show <KEY_NAME> -a --keyring-backend os)
```

### Setting up persistent peers in config.toml

#### Add Persistent Peers to config.toml:

```
vim config.toml
```

Now connect to some peers nodes by setting `persistent_peers.`

#### Example

{% hint style="warning" %}
You can ask for seeds in the discord validator channel.
{% endhint %}

```
persistent_peers = "e4c2267b90c7cfbb45090ab7647dc01df97f58f9@andromeda-m.peer.stavr.tech:4376,258f523c96efde50d5fe0a9faeea8a3e83be22ca@seed.andromeda-1.andromeda.aviaone.com:1028"
```

#### Copy Genesis File:

```
git clone https://github.com/andromedaprotocol/mainnet
cd mainnet
cp genesis.json $HOME/.andromeda/config/
```

### Starting the Network

```bash
andromedad start
```

Your node should now be catching up to the current state of the network!

### Create Validator Command&#x20;

{% hint style="warning" %}
Send yourself some tokens from the Andromeda Faucet before proceeding.
{% endhint %}

```bash
andromedad tx staking create-validator \
  --amount=1000000 uandr \
  --pubkey=$(andromedad tendermint show-validator) \
  --moniker=<MONIKER> \
  --chain-id=andromeda-1 \
  --commission-rate="0.05" \
  --commission-max-rate="0.20" \
  --commission-max-change-rate="0.01" \
  --min-self-delegation="1" \
  --gas="700000" \
  --from=<KEY_NAME>
```

Replace **\<MONIKER>** and **\<KEY\_NAME>** above.

#### Setup andromedad systemd service (copy and paste all to create the file service)

#### &#x20;Enable and activate the andromedad service.

```bash
sudo nano /etc/systemd/system/andromedad.service && sudo touch /etc/systemd/system/andromedad.service 
```

#### Insert content into andromedad.service:

```bash
[Unit]
Description=Andromeda Node
After=network-online.target

[Service]
User=root
ExecStart=/root/go/bin/andromedad start
Restart=always
RestartSec=3
LimitNOFILE=4096

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

#### Move file to systemd folder:

```bash
sudo mv /etc/systemd/system/andromedad.service /lib/systemd/system/
sudo systemctl enable andromedad.service && sudo systemctl start andromedad.service
```

#### Check info about node:

```bash
curl -s localhost:26657/status  | jq .result.sync_info.catching_up
#true output is syncing - false is synced
curl -s localhost:26657/status | jq .result.sync_info.latest_block_height
#this output is your last block synced
curl -s "http://:26657/status?"  | jq .result.sync_info.latest_block_height
#this output the public node last block synced
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.andromedaprotocol.io/andromeda/chain/running-a-node.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.