# Coreum

#### How To Install Full Node Coreum Testnet

### Setting up vars

```
export CORE_CHAIN_ID="coreum-testnet-1"
export CORE_DENOM="utestcore"
export CORE_NODE="https://full-node-pluto.testnet-1.coreum.dev"
export CORE_FAUCET_URL="https://api.testnet-1.coreum.dev"
export CORE_COSMOVISOR_VERSION="v1.3.0"
export CORE_VERSION="v0.1.1"

export CORE_CHAIN_ID_ARGS="--chain-id=$CORE_CHAIN_ID"
export CORE_NODE_ARGS="--node=$CORE_NODE $CORE_CHAIN_ID_ARGS"

export CORE_HOME=$HOME/.core/"$CORE_CHAIN_ID"

export CORE_BINARY_NAME=$(arch | sed s/aarch64/cored-linux-arm64/ | sed s/x86_64/cored-linux-amd64/)
export COSMOVISOR_TAR_NAME=cosmovisor-$CORE_COSMOVISOR_VERSION-linux-$(arch | sed s/aarch64/arm64/ | sed s/x86_64/amd64/).tar.gz

```

### Update packages

```
sudo apt update && sudo apt upgrade -y
```

### Install dependencies

```
sudo apt install curl build-essential git wget jq make gcc tmux net-tools ccze -y
```

### Install go

```
if ! [ -x "$(command -v go)" ]; then
  ver="1.18.2"
  cd $HOME
  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" >> ~/.bash_profile
  source ~/.bash_profile
fi
```

## Download and build binaries

#### Create a proper folder structure for cored.

```
mkdir -p $CORE_HOME/bin
```

#### Download cored and put it in the required folder.

```
curl -LO https://github.com/CoreumFoundation/coreum/releases/download/$CORE_VERSION/$CORE_BINARY_NAME
mv $CORE_BINARY_NAME $CORE_HOME/bin/cored
```

#### Add cored to PATH and make it executable.

```
chmod +x $CORE_HOME/bin/*
```

#### Test cored

```
cored version
```

#### Set the moniker variable to reuse it in the following instructions.

```
export MONIKER="full"
```

### Config app

#### Set Node config

```
CORE_NODE_CONFIG=$CORE_HOME/config/config.toml
```

#### Your Node should have public IP, which you should set there:

```
CORE_EXTERNAL_IP={YOUR_VM_PUBLIC_IP}
```

#### Update node config with CORE\_EXTERNAL\_IP

```
crudini --set $CORE_NODE_CONFIG p2p addr_book_strict false
crudini --set $CORE_NODE_CONFIG p2p external_address "\"tcp://$CORE_EXTERNAL_IP:26656\""
crudini --set $CORE_NODE_CONFIG rpc laddr "\"tcp://0.0.0.0:26657\""
```

### Init app

```
cored init $MONIKER $CORE_CHAIN_ID_ARGS
```

#### Set the config path variables.

```
CORE_APP_CONFIG=$CORE_HOME/config/app.toml
```

### (Optional) Enable REST APIs disabled by default.

```
crudini --set $CORE_APP_CONFIG api enable true # enable API
crudini --set $CORE_APP_CONFIG api swagger true # enable swagger UI for the API
```

### (Optional) Enable prometheus monitoring.Disable indexing

```
crudini --set $CORE_NODE_CONFIG instrumentation prometheus true

```

## Create service

```
sudo tee /etc/systemd/system/cored.service > /dev/null << EOF
[Unit]
Description=Coreum Node
After=network-online.target
[Service]
User=$USER
ExecStart=/root/.core/coreum-testnet-1/bin/cored start
Restart=on-failure
RestartSec=10
LimitNOFILE=10000
[Install]
WantedBy=multi-user.target
EOF
```

### Register and start service

```
sudo systemctl daemon-reload
sudo systemctl enable cored
sudo systemctl restart cored && sudo journalctl -u cored -f -o cat
```

### After sync

#### create wallet

```
cored keys add $MONIKER --keyring-backend os 
```

#### or recover old wallet

```
cored keys add $MONIKER --keyring-backend os --recover
```

### Check balance

```
cored q bank balances  $(cored keys show $MONIKER --address --keyring-backend os) --denom $CORE_DENOM
```

#### Wait until node is fully synced(its important). To check sync status run next command:

```
echo "catching_up: $(echo  $(cored status) | jq -r '.SyncInfo.catching_up')"
```

## Create validator

### set up validator configuration And change your variable below

```
 export CORE_VALIDATOR_DELEGATION_AMOUNT=20000000000 
 export CORE_VALIDATOR_NAME="YourValidatorName" 
 export CORE_VALIDATOR_WEB_SITE="YourSite.com" 
 export CORE_VALIDATOR_IDENTITY="Your Keybase" 
 export CORE_VALIDATOR_COMMISSION_RATE="0.10"
 export CORE_VALIDATOR_COMMISSION_MAX_RATE="0.20" 
 export CORE_VALIDATOR_COMMISSION_MAX_CHANGE_RATE="0.01"
 export CORE_MIN_DELEGATION_AMOUNT=20000000000 
```

### create validator

````cored
--amount=$CORE_VALIDATOR_DELEGATION_AMOUNT$CORE_DENOM \
--pubkey="$(cored tendermint show-validator)" \
--moniker="$CORE_VALIDATOR_NAME" \
--website="$CORE_VALIDATOR_WEB_SITE" \
--identity="$CORE_VALIDATOR_IDENTITY" \
--commission-rate="$CORE_VALIDATOR_COMMISSION_RATE" \
--commission-max-rate="$CORE_VALIDATOR_COMMISSION_MAX_RATE" \
--commission-max-change-rate="$CORE_VALIDATOR_COMMISSION_MAX_CHANGE_RATE" \
--min-self-delegation=$CORE_MIN_DELEGATION_AMOUNT \
--gas auto \
--chain-id="$CHAINID" \
--from=$MONIKER \
--keyring-backend os -y -b block $CORE_CHAIN_ID_ARGS```
````

## Check the validator status.

```
cored q staking validator "$(cored keys show $MONIKER --bech val --address $CORE_CHAIN_ID_ARGS)"
```


---

# 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.konsortech.xyz/node/testnet/coreum.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.