PepePOW (PEPEW) Node Guide

PepePOW is a CPU mineable cryptocurrency that also has tiered masternodes. In this guide, I cover how to setup a node and configure it as a Miningcore SOLO pool. You may also use the resulting node to run it as a masternode in lieu of a mining node.

NOTE: This walkthrough assumes you are running a system on Ubuntu Linux and are already connected to a shell window either directly on the system or via a SSH session. In order to setup the pool part, you also need to be running an instance of Miningcore. If you need to setup Miningcore, I have a Guide for that here

We'll start by first making sure we have our packages up to date and then install docker and git
```
sudo apt update -y
sudo apt install docker.io git -y
```
Next, we'll create folders to store our PePePow Node application files and also our blockchain data in. I'll be placing this at /apps and /data paths. You may want to replace those paths if you have multiple drives with different mount points.
```
sudo mkdir -p /data/.pepew
sudo mkdir -p /apps/pepew
```
Now, we'll clone the PepePOW Github repository to a local folder and then move into that folder
```
sudo git clone https://github.com/MattF42/PePe-core.git /apps/pepew
cd /apps/pepew
```

Next we need to create a Docker config file as PepePOW doesn't ship with a native docker file.

sudo nano Dockerfile

Paste the following text and then do ctrl+x followed by Y and then press the Enter key. This will save and exit.

FROM ubuntu:18.04
RUN apt-get update -y
RUN DEBIAN_FRONTEND=noninteractive apt-get install software-properties-common build-essential libtool autotools-dev automake pkg-config libssl-dev libevent-dev bsdmainutils libboost-all-dev libminiupnpc-dev libzmq3-dev -y
RUN add-apt-repository ppa:bitcoin/bitcoin
RUN apt-get update -y
RUN apt-get install libdb4.8-dev libdb4.8++-dev -y
WORKDIR /app
COPY . .
RUN ./autogen.sh
RUN ./configure --enable-glibc-back-compat --enable-reduce-exports LDFLAGS=-static-libstdc++  CFLAGS="-march=native" CXXFLAGS="-march=native"
RUN make
RUN mv /app/src/PEPEPOWd /app/PEPEPOWd
RUN mv /app/src/PEPEPOW-cli /app/PEPEPOW-cli
CMD /app/PEPEPOWd -printtoconsole

Now we are going to compile it into a local docker image. We are using docker here to simplify starting, stopping, and being able to easily update the node when needed. Please be patient as this step may take 10-20 minutes or more depending on your hardware.
```
sudo docker build -t pepew .
```
Now we need to create a config file for the node. This allows us to define the ports and credentials that the node RPC server runs on that we will use to connect our pool to (if applicable)
```
sudo nano /data/.pepew/PEPEPOW.conf
```
Paste the following text and then do ctrl+x followed by Y and then press the Enter key. This will save and exit.
```
server=1
rpcport=9001
rpcuser=pooluser
rpcpassword=poolpassword
zmqpubhashblock=tcp://127.0.0.1:6001
```
Let's break down what the above settings mean
- server - This tells the node to run the JSON-RPC Server. This is needed to interact with the node (such as getting work, submitting blocks, checking balances, sending funds, etc)
- rpcport - This defines the port number that JSON-RPC server will accept connections on
- rpcuser - This defines the JSON-RPC credentials we can use to connect to interact with the node and wallet
- rpcpassword - This defines the JSON-RPC credentials we can use to connect to interact with the node and wallet
- zmqpubhashblock - This defines a endpoint that our node can push new block notifications too. When running a pool or stratum service, we subscribe to this endpoint so the pool gets real-time notifications that it's time to switch to the next block instead of having to poll the node multiple times a second.
Now we can create and run the docker container for the node. We set restart to always so if the node crashes or system reboots, it will auto start itself back up
```
sudo docker run -d --network host --name pepew --restart always --log-opt max-size=10m -v /data/.pepew:/root/.PEPEPOWcore pepew
```
The container should now be running, create a local wallet, and start syncing the blockchain. You can check the logs with the following command
```
sudo docker logs pepew
```
You will now need to wait for the node to fully sync. If you want to interact with the node or node wallet, you can do so like this:
```
sudo docker exec pepew /app/PEPEPOW-cli getnewaddress
```
After running the above getnewaddress command, make note of the address. You will need it if you are going to configure Miningcore for PEPE POW.

If you want to use this node with Miningcore, here is an example pool config that you can put in the "Pools" array of your Miningcore config file. Replace the address values with what you copied from the "getnewaddress" command earlier

sudo nano /data/.miningcore/config.json

{
  "id": "pepew",
  "enabled": true,
  "coin": "pepepow",
  "address": "PMNxxxxxxxxxxxxxxxxxxxxW",
  "rewardRecipients": [
    {
      "address": "PMNxxxxxxxxxxxxxxxxxxxxW",
      "percentage": 0.001
    }
  ],
  "blockRefreshInterval": 0,
  "jobRebroadcastTimeout": 10,
  "clientConnectionTimeout": 600,
  "banning": {
    "enabled": true,
    "time": 600,
    "invalidPercent": 50,
    "checkThreshold": 50
  },
  "enableInternalStratum": true,
  "ports": {
    "5001": {
      "listenAddress": "0.0.0.0",
      "difficulty": 1,
      "varDiff": {
        "minDiff": 0.01,
        "targetTime": 15,
        "retargetTime": 90,
        "variancePercent": 30
      }
    }
  },
  "daemons": [
    {
      "host": "127.0.0.1",
      "port": 9001,
      "user": "pooluser",
      "password": "poolpassword",
      "zmqBlockNotifySocket": "tcp://127.0.0.1:6001"
    }
  ],
  "paymentProcessing": {
    "enabled": true,
    "minimumPayment": 100,
    "autoExchangingFromEnabled": true,
    "autoExchangingToEnabled": true,
    "autoExchangingFee": 5,
    "payoutScheme": "SOLO",
    "payoutSchemeConfig": {
      "factor": 2
    }
  }
}

If you added the coin to Miningcore, make sure you restart the miningcore service
```
sudo docker restart miningcore
```
If you added the coin to Miningcore, you can now connect your miners to the port configured. If you are exposing over the internet, make sure you open up the stratum port configured (5001), Miningcore API port (4000), and Miningcore Web UI port (80)
Congrats, you now have PEPE POW Node setup and optionally your own mining pool with Miningcore. If you find youself wanting to update to the latest version of PEPE POW at some point in the future, you can run these commands:
```
cd /apps/pepew
sudo git pull
sudo docker build -t pepew .
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once pepew
```

If you found this guide valueable, please consider donating to help me continue to create similar guides