Ubuntu 16.04

Daemon

sudo apt-get update -y && sudo apt-get upgrade -y
sudo apt-get install -y git unzip build-essential libssl-dev libdb++-dev libboost-all-dev libqrencode-dev libminiupnpc-dev libgmp-dev libevent-dev autogen automake  libtool libcurl4-openssl-dev
git clone https://github.com/carsenk/denarius
cd denarius
git checkout master
git pull
cd src
make -f makefile.unix
sudo mv ~/denarius/src/denariusd /usr/local/bin/denariusd
denariusd

QT

sudo apt-get update -y && sudo apt-get upgrade -y
sudo apt-get install -y git unzip build-essential libssl-dev libdb++-dev libboost-all-dev libqrencode-dev libminiupnpc-dev libevent-dev autogen automake  libtool libqt5gui5 libqt5core5a libqt5dbus5 qttools5-dev qttools5-dev-tools qt5-default libcurl4-openssl-dev
git clone https://github.com/carsenk/denarius
cd denarius || exit
git checkout master
git pull
qmake "USE_QRCODE=1" "USE_UPNP=1" denarius-qt.pro
make
./Denarius

First create an index.html file with your site.

Now go to the QT wallet, click the Jupiter tab, select your file and click Upload to IPFS.

Once the file uploads you get the IPFS hash. Click view on Infura or Cloudflare. Lets add one more twist to make this easier to find.

I am going to use namecheap as an example of how to create a subdomain to the IPFS hash.

Add a TXT record to your new IPFS hash.

I am using ipfschain as my subdomain and dnslink=/ipfs/QmPm4AUBGsTjiKN3UtxTtarw4CKAcPNSVjNU18Tjrm6N7R as the IPFS hash.

Save this, wait a few minutes and now try

https://cloudflare-ipfs.com/ipns/ipfschain.pos.watch

Setup a VM, VPS, raspberry pi, whatever to play on this. Anything breaks its pretty easy to delete stuff. Using ubuntu/debian for the example.

The idea is relatively simple. Ask the daemon for information, throw that into influxdb and then have Grafana pull from that database.

Install denarius daemon
Install python denarius rpc
https://github.com/buzzkillb/python-denariusrpc
Install grafana
https://grafana.com/docs/grafana/latest/installation/debian/
Install influxdb
https://docs.influxdata.com/influxdb/v1.7/introduction/installation/

One this is all done we need a test to see if python is working with the daemon. Switch in rpc_user and rpc_password that's inside of denarius.conf

test.py

from denariusrpc.authproxy import AuthServiceProxy, JSONRPCException
# rpc_user and rpc_password are set in the denarius.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:32369"%(rpc_user, rpc_password))
best_block_hash = rpc_connection.getbestblockhash()
print(rpc_connection.getblock(best_block_hash))
# batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips:
commands = [ [ "getblockhash", height] for height in range(100) ]
block_hashes = rpc_connection.batch_(commands)
blocks = rpc_connection.batch_([ [ "getblock", h ] for h in block_hashes ])
block_times = [ block["time"] for block in blocks ]
print(block_times)

test run

python test.py

Lets double check another test run to get current Denarius price from Coinvex.

testcoinvex.py

from denariusrpc.authproxy import AuthServiceProxy, JSONRPCException
import requests, urllib, json
#southexchange
#coinvex
coinvex_url = requests.get('https://coinvex.org/api/v1/public/getlastmarketdata')
coinvex_data = json.loads(coinvex_url.text)
coinvex_price = coinvex_data['result']['coins']
for r in coinvex_price:
    if r["name"] == "Denarius":
        coinvex_last = float(r["price"])
        print format(coinvex_last, '0.8f')

test run

python testcoinvex.py

Works? The next post will show how to take this data and put into influxdb.

Always backup wallet.dat to a safe location.

To sync your new Denarius QT Wallet or denariusd, download chaindata.zip from here

https://chaindata.pos.watch/

Then unzip the chaindata.zip file to your Denarius data directory.

(Linux location of Denarius default datadir is ~/.denarius/)

cd ~/.denarius
rm -rf database txleveldb smsgDB
wget https://chaindata.pos.watch/chaindata.zip
unzip chaindata.zip

(macOS Location of Denarius default datadir is /Library/Application Support/Denarius)

(Windows Location of Denarius default datadir is C:/Users/<yourname>/AppData/Roaming/Denarius)

Run the QT Wallet or denariusd after extracting the .zip and you will sync to the blockchain fast.

If you get an error when starting the QT or denariusd, go to the database folder and delete the files inside, and restart the wallet. Also ensure you run ./denariusd stop to stop the denariusd if running before unzipping chaindata.

Use 7zip for Windows unzipping. https://www.7-zip.org/download.html

Install IPFS (locally or vps)
https://docs.ipfs.io/guides/guides/install/

Ubuntu (AMD64)
Find latest here - https://dist.ipfs.io/#go-ipfs

wget https://dist.ipfs.io/go-ipfs/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz
tar xvfz go-ipfs_v0.4.22_linux-amd64.tar.gz
cd go-ipfs
sudo ./install.sh
ipfs version

#start ipfs node and take note of your IPFS node ID

ipfs init

#example output

```
initializing IPFS node at /home/travanx/.ipfs
generating 2048-bit RSA keypair...done
peer identity: QmNyud5DGEmkBGYcV4QA69JHiTuWLU6EkStpviddZTgiag
to get started, enter:

    ipfs cat /ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv/readme
```

#try reading the readme

ipfs cat /ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv/readme

#start IPFS service

ipfs daemon

denarius.conf

jupiterlocal=1

if you want to specify your IPFS server and its not local add

jupiterip=yournodeIP:5001

To upload a file
#example command to upload using daemon or QT from debug console, other use the Jupiter tab in the QT

jupiterupload /home/USERNAME/Downloads/denarius-256.png

Carsen uploaded the below image using localhost, then turned off his localhost IPFS server and because Denarius is amazing the file still shows up.

Lets pick a good file to Proof of Data against and then upload into IPFS.

Current Release: https://github.com/carsenk/denarius/releases/tag/v3.3.9.6
QT Wallet: https://github.com/carsenk/denarius/releases/download/v3.3.9.6/Denarius-v3.3.9.6-Win64.zip

Download a file, I am going to use the denarius logo from denarius.io and lets proof of data this and upload to IPFS as a great example of how powerful this is. Here's a link but just right click the image on the homepage and save to your hard drive.

https://i2.wp.com/denarius.io/wp-content/uploads/2017/11/denarius-256.png?w=256&ssl=1

Go to the Jupiter Tab

Select your file, in this case select the image file we just downloaded.

Click Upload to IPFS (The Wallet will freeze while the upload is taking place)

After the upload you will get an IPFS Hash along with being able to click the link to see the file in your web browser.

Success, and currently there are file limits on uploading through the wallet. I was not able to upload the QT.zip yet.

Lets Proof of Data this file for good measure, so the original hash is located on the Denarius blockchain.

Go to Proof of Data tab in QT Wallet

Select our image, then put a simple narration in and then click Create Timestamp

This now gives us a D address where the hash matches the image. Now if we download the image we uploaded to IPFS we can verify the file against the blockchain by checking against PoD again.

Here is our set in the blockchain address based on the image file or can Click Check Transaction to get to your PoD transaction.

https://www.coinexplorer.net/D/address/DQQxYgD1KPzmoQGeL1JyXZk2JhZPfiaXsY

If you have multiple fortunastakes, somehow you want to get each json of your fortunastake status onto a single nginx server. Depends a lot on how to go about this.

I am using blocknotify on the daemon to create 1.json and 2.json files, also grab the current block from blocknotify send that to block.txt, sending these files to /var/www/html and then making sure permissions are what I want.

Install nginx on your ubuntu you will be using.

sudo apt install nginx

Verify that works by going to your ip address. I am doing everything on a local network, this is gonna vary, but if its working you should see the default nginx welcome screen.

denarius.conf (change the full path to your server, maybe /home/username/status.sh)

blocknotify=/root/status.sh

status.sh (creates block.txt and iterates through 2 fortunastakes on same server at directories /root/D01 and /root/D02, i<3 is +1 of the number you are running if on same server)

#!/bin/bash
denariusd -datadir=/root/D01 getblockcount > /var/www/html/block.txt
#stop and start 01-02
for ((i=1; i<3; i++))
do
echo "$i"
denariusd -datadir=/root/D0$i fortunastake status > /var/www/html/$i.json
chmod -R 644 /var/www/html/*
done

Restart the daemon and on the first new block status.sh will run and send the files into /var/www/html. Double check the directory has some files after running for a bit.

Basically you want to get each of your Fortunastakes json files into your /var/www/html, maybe even using scp from multiple vps's. Just make sure to label them 1.json 2.json 3.json and so forth for how we will iterate through these json files.

example of using scp command way to do it, you want ssh-key login if using scp

scp 2.json [email protected]:/var/www/html/2.json

Create 4 files we will use to create the website, stick them in /var/www/html folder

style.css

body
{
background: #020000;
font-family: 'Raleway', sans-serif;
font-size:16px;
}
.row {
  display: flex;
  flex-wrap: wrap;
}
.col {
  flex: 1 0 18%; /* The important bit. This percentage decides your columns. 
 The percent can be px. It just represents your minimum starting width.
  */
  margin: 0.5px;
  background: #333333;
  height: 30px;
  color: white;
  display: flex;
  align-items: center;
  justify-content: center;
}
/* visited link */
a:visited {
  color: white;
}
/* unvisited link */
a:link {
  color: white;
}

fortunastake.js

fetchData = () => {
  const urls = [
    "1.json", "2.json"
  ];
  const allRequests = urls.map(url => 
    fetch(url).then(response => response.json())
  );
  return Promise.all(allRequests);
};
fetchData().then(arrayOfResponses => {
for (index = 0; index < arrayOfResponses.length; index++) { 
    window.FS = '<div class="row">' + 
                '<div class="col">FS' + [index+1] + '</div>' + 
                '<div class="col">' + (arrayOfResponses[index].local.service) + '</div>' + 
                '<div class="col">' + '<a href="https://www.coinexplorer.net/D/address/' + (arrayOfResponses[index].local.payment_address)  + '">' + (arrayOfResponses[index].local.payment_address) + '</a></div>' +
                '<div class="col">' + (arrayOfResponses[index].local.network_status) + '</div>' +
                '<div class="col">' + parseFloat((arrayOfResponses[index].local.earnings) / 100000000).toFixed(8) + '</div>'
                + '</div>';
    console.log(window.FS)
    $("#fsnumber").append(window.FS).hide().fadeIn("fast");
}
}
);

block.html

fetch('block.txt', {mode: 'no-cors'})
  .then(function(response) {
    return response.json();
  })
  .then(function(data) {
    if (data)
      console.log(data);
        $('#block').html("");
        $("#block").append(data).hide().fadeIn("slow");
  })
  .catch(function(err) {
    console.log(err);
  });
var listen = setInterval(function() {
    fetch('block.txt', {mode: 'no-cors'})
      .then(function(response) {
        return response.json();
      })
      .then(function(data) {
        if (data)
          console.log(data);
            $('#block').html("");
            $("#block").append(data).hide().fadeIn("slow");
      })
      .catch(function(err) {
        console.log(err);
      });
}, 30000);//30 second

index.html

<html>
  <head>
    <title>FortunaStake List</title>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/3.7.2/animate.min.css">
    <script type="text/javascript" src="block.js?version=0.1337"></script>
    <script type="text/javascript" src="fortunastake.js?version=0.1337"></script>
    <link rel="stylesheet" type="text/css" href="style.css?version=0.1337">
  </head>
<body>
<div class="row">
  <div class="col">FortunaStake List</div>
</div>
<div class="row">
  <div class="col">Block #<div id="block"; style="display:inline-block"; class="animated rubberBand"></div></div>
</div>
  <div id="fsnumber"></div>
</body>
</html>

Go back to your nginx IP and force refresh by using shift+ctrl+r and now you can start watching your Fortunastake Status from wherever.

This uses a 5 column flex grid and has clickable link to coinexplorer per address and auto refreshes the block count every 30 seconds. This does not autorefresh the FS list though.

FS # | IP Address | FS Address | Status | Round Earnings

What it shows when one goes down from the list. This particular one lost sync on the daemon, and still shows active as I restarted the QT. Was about to get bumped off to inactive and REKT.

denarius.conf

maxconnections=8
maxuploadtarget=500
listen=0

or run with flags

-maxconnections=8 -maxuploadtarget=500 -listen=0

For a single coin pool, a $5 Vultr VPS Appears to work so far. This is 1 cpu, 1GB ram.

Also grab a domain name from somewhere like namecheap with whois guard. You then want to create an A record that points the domain name to your VPS IP and let this propogate. This generally takes 1-2 hours. I use https://dnschecker.org/#A to check the DNS switched over.

I setup the denarius daemon first to double check I can compile coins. Some cheaper VPS's will not allow swap drives to compile and even fake swap space doesn't work sometimes. A nice feature of Vultr is that you can upgrade and not lose your data. They still also allow free snapshots of your VPS.

After you compile denariusd, start daemon. Note the RPC user and pass this randomly generates and copy and paste those somewhere. Edit the denarius.conf and add those and a couple other lines to start the daemon syncing.

nano ~/.denarius/denarius.conf

Add these lines.

RPCUSERNAME=FROMABOVE
RPCPASSWORD=FROMABOVE
daemon=1

Restart denariusd and let that sync in the background and start the Yiimp script install.

adduser pool
adduser pool sudo
su - pool
sudo apt-get -y install git
git clone https://github.com/xavatar/yiimp_install_scrypt.git
cd yiimp_install_scrypt/
sudo bash install.sh

Use this link for the timezone you will input into the beginning of the script
http://php.net/manual/en/timezones.php

Keep everything as default. Yes you want to use letsencrypt so the domain is automatically setup for https. Also you need to grab your home IP so only that IP can login to the Yiimp control panel. Also need an email for alerts. Also you admin panel can be named anything which you get the option here. Example https://example.com/site/ICOULDNAMEMYADMINPANELTHIS. Inputting through the steps, sit back and watch the script go to work. This will take anywhere from 30min to over an hour depending on the VPS.

After the initial setup is done, go to your new domain name and see the website is setup, but no coin is there to mine.

At your panel click Wallets at the top of the menu bar and scroll down to see CREATE COIN.

Fill in this Data thats underlined in red on the General Tab. Here is a direct link for a D logo. Which Yiimp automatically adds.

https://i.imgur.com/jv3U2nF.png

On the Settings tab checkmark similar things, and wait to add D addresses for once we are done setting up these tabs.

On the Deamon tab fill in the underlined red.

Click Save.

Go back to that config screen by clicking COIN PROPERTIES.

Go back to the Deamon tab and under sample config you want to copy and paste that entire area and paste into your denarius.conf file at ~/.denarius/denarius.conf

At the VPS command line

nano ~/.denarius/denarius.conf

Change the last line blocknotify to this. Full denarius.conf example below.

rpcuser=USERNAME
rpcpassword=PASSWORD
rpcport=32369
rpcthreads=8
rpcallowip=127.0.0.1
maxconnections=12
daemon=1
gen=0
alertnotify=echo %s | mail -s "Denarius alert!" [email protected]
blocknotify=/var/stratum/blocknotify 127.0.0.1:8533 1425 %s

Open up your firewall for port 8533 for mining and also allow 33369 for denarius daemon port.

sudo ufw allow 8533 33369

Now stop denariusd from syncing earlier and rerun. Some sample tutorials are running this with sudo. Not sure if this is required.

denariusd

Once that gets syncing again we need an address. I did it like this.

denariusd getnewaddress
denariusd getaccountaddress default

And I used that default address in the Settings Tab -> Master Wallet and Daemon Tab -> Account

Go back into the Yiimp control panel, click wallets again at the top right and then Select Server and choose 127.0.01 to get your list of coins you have added.

Once the daemon is done syncing go back to admin panel to the Settings Tab and click Enable and Auto Ready.

Change the stratum script before running which is in that yiimp folder you cloned in.

nano screen-stratum.sh

And change to

#!/bin/bash
 STRATUM_DIR=/var/stratum
screen -dmS tribus $STRATUM_DIR/run.sh tribus

I would remove root login access and remove password login for VPS login accounts and only use SSH keys, as a starting point to start locking the VPS down.

2 Things I changed from the default install.

Payout Frequency to every hour.

/var/web/serverconfig.php
define('YAAMP_PAYMENTS_FREQ', 1*60*60);

And somewhere I saw this helped with payout issues.

/var/web/yaamp/core/backend/payment.php
line57
if($coin->symbol == 'BOD' || $coin->symbol == 'D' || $coin->symbol == 'DIME' || $coin->symbol == 'BTCRY' || !empty($coin->payout_max))

If you are looking to edit the website text, go to https://github.com/tpruvot/yiimp

And search a small portion of the text you are looking to change, and this will show you the file to edit.

This will take 500 confirms before being able to start, so do the send first, then read through the guide. Send exactly 5000 D to an address and give that address a label like FS01.

Script for VPS Portion Located Here
This will pull master branch and compile the latest wallet. And add a cronjob to restart wallet every hour to make sure things stay in sync.

https://github.com/buzzkillb/d-fortunastake

QT Wallet
After sending 5000 D to a labelled address, we need the following; transaction hash and index of the 5000 send, fortunastake private key, and your VPS IP address.

FS01 VPSIPADDRESS:9999 FORTUNASTAKEPRIVKEY TRANSACTIONHASH INDEXNUMBER

Sample fortunastake.conf

FS01 11.11.12.13:9999 6J8tAUsVhXBgfdeewqsdghySWEQEeb4XGSC251sM7bYQgEXh7 f08d926f92cc4c65321344828f6394f41121903502459ffde4ef7aef39e6392b 0

fortunastake private key

fortunastake genkey

fortunastake transaction hash and id

fortunastake outputs

VPS of your ip should be somewhat obvious.

After creating your fortunastake.conf, save and restart the QT wallet.

Sample QT denarius.conf

fsconflock=1
staking=1

Now that address has locked the 5000 D collateral.

VPS
Get a VPS from somewhere like Vultr, make note of its IP address for the above fortunastake.conf creation for the QT wallet. On the VPS

Update Linux

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

Install Dependencies
 

sudo apt-get install -y git unzip build-essential libssl-dev libdb++-dev libboost-all-dev libqrencode-dev libminiupnpc-dev libgmp-dev libevent-dev autogen automake  libtool

Install Fail2Ban

sudo apt install fail2ban

Create Swap File

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Install Firewall

sudo apt install ufw -y
ufw default deny incoming
ufw default allow outgoing
ufw allow ssh/tcp
ufw limit ssh/tcp
ufw allow 33369/tcp
ufw allow 9999/tcp
ufw logging on
ufw --force enable

Compile and Install Wallet (most likely need to add swapfile below). If using 18.04 use this link instead of the instructions below https://denariustalk.org/index.php?/topic/268-steps-to-compile-wallet-ubuntu/&do=findComment&comment=2815

git clone https://github.com/carsenk/denarius
cd denarius
git checkout master
cd src
make -f makefile.unix
strip denariusd
sudo mv ~/denarius/src/denariusd /usr/local/bin/denariusd

Install Chaindata

apt-get -y install unzip
mkdir ~/.denarius
cd ~/.denarius
rm -rf database txleveldb smsgDB
wget https://pos.watch/chaindata.zip
unzip chaindata.zip

Create denarius.conf in the .denarius folder. Notice the . in the folder name.

denarius.conf

rpcuser=USEARANDOMNAME
rpcpassword=USEARANDOMPASSWORD
daemon=1
port=9999
fortunastakeprivkey=6J8tAUsVhXBgfdeewqsdghySWEQEeb4XGSC251sM7bYQgEXh7

run denariusd by typing

denariusd

Start

Go back to your QT, go to debug console and type.

fortunastake start-alias FS01

In the My Denarius Fortuna Stakes tab in your QT collateral wallet, the QT will show Registered once you start your FortunaStake and then Verified, then Online, then Active. Wait 1 complete round for rewards. 1 round is roughly how many ForTunaStakes are up, and that's how many blocks a round will last.

Status Check

masternode status still works for specific reasons, but fortunastake status gives info in English instead of numbers and gibberish.

fortunastake status

To install

sudo apt update
sudo apt install snapd
sudo snap install denarius

To run QT

denarius

To run the daemon

denarius.daemon

chaindata stored in ~/snap/denarius/common/.denarius

cd ~/snap/denarius/common/.denarius

Sample daemon command

denarius.daemon getinfo

stop daemon

denarius.daemon stop

Remember to use a strong unique password and enable 2FA.

After validating your email, go to the Addresses list and then click Create Deposit Address

In this example we are depositing Bitcoin. Type BTC to find Bitcoin and push enter, then click next to get your Bitcoin Deposit Address.

Deposit Bitcoin into the exchange by either copy and pasting the BTC address, or use the QT code on something like coinomi with a camera.

After clicking continue you will be brought back to the address list again.

Wait for your confirmations after sending Bitcoin in and start buying up Denarius!

Bitcoin takes 10 minutes per confirmation, and currently the exchange requires 2 confirmations for a deposit of Bitcoin.
Denarius takes 30 seconds per confirmation, and currently the exchange requires 20 confirmation for a deposit of Denarius.

https://github.com/buzzkillb/d-snapcraft

We are going to build in LXD, which I ended up using a combination of the below guides.

https://forum.snapcraft.io/t/how-to-create-a-lxd-container-for-snap-development/4658
https://forum.snapcraft.io/t/build-on-lxd/4157

Install LXD from snap

sudo snap install lxd

initialize LXD (I used all the default settings)

sudo lxd init

Give permissions so we can run without root

sudo usermod -a -G lxd ${USER}

Bring the setting through

newgrp lxd

Building Manually in Xenial

lxc launch ubuntu:16.04 mysnapcraft

Bring your snapcraft.yaml in from your PC and bring into LDX

lxc file push snap/snapcraft.yaml mysnapcraft/home/ubuntu/

Open up a shell and install snapcraft

lxc exec mysnapcraft -- /bin/bash 
snap install snapcraft --classic

Lets build our snapcraft.yaml

cd /home/ubuntu
snapcraft prime
snapcraft

You will get a file like this

denarius_master_amd64.snap

Bring the snap into your PC, open up another terminal and type below and stay on that terminal for the remaining.

sudo lxc file pull mysnapcraft/home/ubuntu/denarius_master_amd64.snap denarius_master_amd64.snap

Install the snap

sudo snap install denarius_master_amd64.snap --dangerous

Run denarius QT

denarius

Should be ready to mess around with this.

I'm interested in setting some sort of masternode thing up - which are the most recent and relevant instructions for setting up on Ubuntu 18.04?

I have access to a VPS but I'm getting confused as to what's what and where's that go.

Any and all advice will be appreciated!

Thx m8s

https://github.com/buzzkillb/duct-tape-dns-seeder

Make a cloudflare account and point your domain denarius.pro at the cloudflare nameservers from your domain host control panel. Now we can edit records on cloudflare and the changes are almost immediate.

Cloudflare API Key is here, top right Icon -> My Profile -> View Global API Key

#Install Python Cloudflare

sudo apt install python-pip
git clone https://github.com/cloudflare/python-cloudflare
cd python-cloudflare
./setup.py build
sudo ./setup.py install

#Create a config file for your cloudflare API, change email and token (API KEY)

mkdir ~/.cloudflare
nano ~/.cloudflare/cloudflare.cfg

[CloudFlare]
email = <user@example.com>
token = <API KEY>
certtoken = v1.0-...
extras =

#test this works. change the ipv4 and denarius.pro to your stuff. dnsseed.denarius.pro is what my example will show.

cli4 --post name="dnsseed" type="A" content="73.218.220.108" /zones/:denarius.pro/dns_records

now we want to store a couple text files somewhere. you choose this for now I will use /root/

#create seed.sh and edit denarius.pro to your domain name. still using dnsseed.denarius.pro for this example.

#!/bin/sh
grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' "${1:?}" |
while read IP
do
    echo "$IP"
    cli4 --post name="dnsseed" type="A" content="$IP" /zones/:denarius.pro/dns_records
done

make this file executable

chmod +x seed.sh

now how to grab and put the ipv4's into the domain A records. denariusd daemon send peerinfo into a json file. then jq parses the json for the addr array and then we remove some junk and put that into peers.txt. From there the bash file uses regex to make the ipv4's pretty.

denariusd getpeerinfo > peer.json
jq '.[] | .addr' -r peer.json | sed 's/[][]//g' > peers.txt
./seed.sh peers.txt

This can be updated as much as the cloudflare API limits gives. But how to remove A records and try to keep this list fresh?

Lets make a delete file from python cloudflare examples. https://github.com/cloudflare/python-cloudflare/blob/master/examples/example_delete_zone_entry.py

#create delete.py and chmod+x this, and then put this inside.

#!/usr/bin/env python
"""Cloudflare API code - example"""
from __future__ import print_function
import os
import sys
import re
import json
import requests
sys.path.insert(0, os.path.abspath('..'))
import CloudFlare
def main():
    """Cloudflare API code - example"""
    try:
        zone_name = sys.argv[1]
        dns_name = sys.argv[2]
    except IndexError:
        exit('usage: example_delete_zone_entry.py zone dns_record')
    cf = CloudFlare.CloudFlare()
    # grab the zone identifier
    try:
        params = {'name':zone_name}
        zones = cf.zones.get(params=params)
    except CloudFlare.exceptions.CloudFlareAPIError as e:
        exit('/zones %d %s - api call failed' % (e, e))
    except Exception as e:
        exit('/zones.get - %s - api call failed' % (e))
    if len(zones) == 0:
        exit('/zones.get - %s - zone not found' % (zone_name))
    if len(zones) != 1:
        exit('/zones.get - %s - api call returned %d items' % (zone_name, len(zones)))
    zone = zones[0]
    zone_id = zone['id']
    zone_name = zone['name']
    print('ZONE:', zone_id, zone_name)
    try:
        params = {'name':dns_name + '.' + zone_name}
        dns_records = cf.zones.dns_records.get(zone_id, params=params)
    except CloudFlare.exceptions.CloudFlareAPIError as e:
        exit('/zones/dns_records %s - %d %s - api call failed' % (dns_name, e, e))
    found = False
    for dns_record in dns_records:
        dns_record_id = dns_record['id']
        dns_record_name = dns_record['name']
        dns_record_type = dns_record['type']
        dns_record_value = dns_record['content']
        print('DNS RECORD:', dns_record_id, dns_record_name, dns_record_type, dns_record_value)
        try:
            dns_record = cf.zones.dns_records.delete(zone_id, dns_record_id)
            print('DELETED')
        except CloudFlare.exceptions.CloudFlareAPIError as e:
            exit('/zones.dns_records.delete %s - %d %s - api call failed' % (dns_name, e, e))
        found = True
    if not found:
        print('RECORD NOT FOUND')
    exit(0)
if __name__ == '__main__':
    main()

to run the deleter, and it appears this only deletes 10-15 records at a time, so you might need to run this 5 times before sending a fresh list. This is only deleting records from dnsseed.denarius.pro. Nothing else on denarius.pro. Magical.

./delete.py denarius.pro dnsseed

Right now I am trying to think how frequent to send new ip's and delete the list and start over. Once I get that down I will post a sample cronjob to use. Otherwise this should work with basically any bitcoin fork daemon, maybe minor tweaks.

I also need a better regex to parse ipv6 so we can also make some on the fly AAAA records.

Use the github as that shows the crontab for adding and deleting the A records

Get a domain like denarius.guide for our example. The dns seeder nameserver will be dnsseed.denarius.guide

Go to your domain and point it to the given he.net servers so he.net is handling your records.

Lets add the first part.

This creates

dnsseed.denarius.guide.	86400	IN	NS	seeder.denarius.guide.

Now lets point seeder.denarius.guide to our vps ip.

This creates

seeder.denarius.guide.	86400	IN	A	163.172.157.116

Also can create an AAAA record because IPv6 is the future right?

This creates

seeder.denarius.guide.	86400	IN	AAAA	2001:bc8:47a0:1933::1

On the vps side we need our dns seeder. Clone a seeder repo, get dependencies, and compile. This could vary depending on OS and VPS.

git clone https://github.com/buzzkillb/d-seeder
sudo apt-get install build-essential libboost-all-dev libssl-dev
make -j2

Run the seeder for a while, and wait for the DNS to propagate. I also sudo apt install tor just because

./dnsseed -h dnsseed.denarius.guide -n seeder.denarius.guide -m buzz.denarius.io -o 127.0.0.1:9050

How to check if this is working.

https://www.whatsmydns.net/#NS/dnsseed.denarius.guide

https://www.qubes-os.org/

Basic Idea (but does not work, don't even bother trying to decipher their ubuntu guide as its for someone who somehow knows how to do this already)
https://www.qubes-os.org/doc/building-archlinux-template/

Reddit Guide (copying some of the steps from this old guide with some edits to work on Qubes 4.0 as this was written for Qubes 3.2)

https://www.reddit.com/r/Qubes/comments/5vzg04/idiots_guide_to_installing_qbuntu_ubuntu_1604/

#gpg stuff from qubes themselves
reference: https://wiki.qubes.rocks/Security/VerifyingSignatures

Lets Begin

Clone your fedora-30 vanilla template into a temporary 'builder' we will use to create Ubuntu templates.
[user@dom0 ~]$ qvm-clone fedora-30 ubuntu-builder
Edit the VM Settings for the newly created template 'ubuntu-builder' (via Qubes Manager GUI), enable 'Allow network access' & increase 'Private storage max size' to 30GB, then start a terminal in ubuntu-builder and initialize GPG
[user@ubuntu-builder ~]$ gpg
Break out of "type your message..." with CTRL+C, import Qubes master key
[user@ubuntu-builder ~]$ gpg --recv-keys 0x36879494
Set trust level for qubes master key
[user@ubuntu-builder ~]$ gpg --edit-key 36879494
gpg> trust
>Your decision? 5
>Do you really want to set this key to ultimate trust? Y
gpg> quit
Now retrieve and import Qubes developer keys
[user@ubuntu-builder ~]$ wget http://keys.qubes-os.org/keys/qubes-developers-keys.asc
[user@ubuntu-builder ~]$ gpg --import qubes-developers-keys.asc

#install nano
[user@ubuntu-builder ~]$ sudo dnf install nano

Install the packages we need to retrieve and run qubes-builder
[user@ubuntu-builder ~]$ sudo dnf install git createrepo rpm-build rpm-sign make python-sh rpmdevtools rpm-sign dialog
Retrieve the qubes-builder from GIT repository
[user@ubuntu-builder ~]$ git clone https://github.com/QubesOS/qubes-builder
[user@ubuntu-builder ~]$ cd qubes-builder
Edit default config to enable debian_builder only in setup script (example used VI but you can use text editor of your choice, like nano installed above)
[user@ubuntu-builder qubes-builder]$ vi example-configs/qubes-os-r4.0.conf
(to check our current version installed, go to Qube Manager -> About -> Qubes OS)
Change these lines to look like this

DIST_DOM0 ?= fc30
DISTS_VM ?=

hint: DOM0 distro being fc30 in this Qubes install, & remove "fc30 buster" from above
save and exit (shift-z-z if using vi)

Setup qubes-builder and compile the template

Run the qubes-builder setup script
[user@ubuntu-builder qubes-builder]$ ./setup
Y to add whats missing
then yes to add missing keys
this failed on me the first time, I ctrl+c and reran ./setup again, did Y again, and it found the keys that were missing after selecting YES, had to even shutdown the qube and try again as it kept glitching out trying to retrieve keys
select 4.0

stable

dont select current or current-testing (wtf? is this madness)

yes (to only build the template)

select xenial+desktop with spacebar and push enter

select Builder-rpm builder-debian only, nothing else. (I was using the guide to test installing Bionic 18.04 for screenshots)

#now you are back at the command prompt and type these in, one by one. The last 2 will take some time so go to Denarius discord and chat with us while waiting. https://discord.gg/7zcwXJN

make install-deps
make get-sources
make qubes-vm
make template

We have our Ubuntu 16.04 template, now to install it!

Qubes-builder should have created an install script, let's make sure it exists:
[user@ubuntu-builder qubes-builder]$ ls -altr qubes-src/linux-template-builder/rpm
You should see an 'install-template.sh' file there. Now switch back to your dom0 terminal, and install the template:
[user@dom0 ~]$ qvm-run --pass-io ubuntu-builder 'cat /home/user/qubes-builder/qubes-src/linux-template-builder/rpm/install-templates.sh' > install-templates.sh
Make the copied script executable and run it
[user@dom0 ~]$ chmod +x install-templates.sh
[user@dom0 ~]$ ./install-templates.sh

#make template (clone) just for denarius, why not
in dom0 terminal emulator

qvm-clone xenial-desktop denarius-crypto

goto qubes-settings for denarius-crypto qube and add your network (I used sys-whonix running tor), run terminal and start to compile the wallet
I am choosing color purple background to break out any crypto stuff so I know be careful
ignore any errors (pulse audio)

#compile denarius QT in template: denarius-crypto

sudo apt-get update -y && sudo apt-get upgrade -y
sudo apt-get install -y git unzip build-essential libssl-dev libdb++-dev libboost-all-dev libqrencode-dev libminiupnpc-dev libevent-dev autogen automake  libtool libqt5gui5 libqt5core5a libqt5dbus5 qttools5-dev qttools5-dev-tools qt5-default
git clone https://github.com/carsenk/denarius
cd denarius
git checkout master
git pull
qmake "USE_QRCODE=1" "USE_UPNP=1" denarius-qt.pro
make -j2
sudo cp Denarius /usr/local/bin

#setup appvm with name
reference: https://www.qubes-os.org/doc/managing-appvm-shortcuts/

sudo nano /usr/share/applications/denarius.desktop

[Desktop Entry]
Version=3.3.9.2
Type=Application
Terminal=false
Icon=/home/user/denarius/src/qt/res/icons/denarius-256.png
Name=Denarius
GenericName=wallet
Comment=Denarius
Categories=crypto;cryptocurrency;
Exec=Denarius

in dom0 run qvm-sync-appmenus denarius-crypto
now you can add Denarius to your app selection list in the template

select denarius from your template: denarius-crypto and start syncing eet

Download Coldfolio from https://whopper.io/ which links to the Google Play Store.

Add a card

Select your Crypto from the List

Scan QR Code from the Denarius QT Wallet
go to receive tab, click address and then click below Show QR Code

Label your Card in Coldfolio and double check you only have the address
This example shows the ?label=MN2, delete this part. This can always be modified later by hodling down the card and clicking modify.

Keep track of your staking, masternodes, balances.

By Carsen K

First download Xcode from the App Store (v10.x)

Install Xcode Command Line Tools via your Terminal:

sudo xcode-select --install

Accept Xcode License

sudo xcodebuild -license

Type agree after hitting space to get to the end

--------------------------------------------------------

Download Qt 5.3.2 from: https://download.qt.io/archive/qt/5.3/5.3.2/qt-opensource-mac-x64-clang-5.3.2.dmg

Install Qt and Qt Creator from this dmg (no need to install source files)

Now in your default_pre.prf file inside your Qt 5.3.2 install change the following lines

Example Location:

Qt_install_folder/5.3.2/5.3/clang_64/mkspecs/features/mac/default_pre.prf

REPLACE:

isEmpty($$list($$system("/usr/bin/xcrun -find xcrun 2>/dev/null")))

WITH:

isEmpty($$list($$system("/usr/bin/xcrun -find xcodebuild 2>/dev/null")))

Sometimes you just need to comment out line 16 the line below this (#error()) for Qt to recognize Xcode

--------------------------------------------------------

Then download MacPorts from: https://www.macports.org/install.php

Once installed run the following command in your Terminal to install all required Denarius dependancies.

sudo port install boost db48 qrencode libevent miniupnpc openssl git

Now you are almost ready to compile!

--------------------------------------------------------

git clone https://github.com/carsenk/denarius
cd denarius

Now inside your denarius-qt.pro on line 14, replace the current QMAKE_CXXFLAGS with:

QMAKE_CXXFLAGS += -fpermissive -Wno-literal-suffix -stdlib=libc++

Run this command in your terminal session with the denarius folder open, replace your username with your username or the entire path below with your correct QT location.

export PATH=$PATH:/Users/<yourname>/Qt5.3.2/5.3/clang_64/bin

Run qmake --version which should return Qt 5.3.2

You can now compile Denarius with the usual commands

qmake "USE_UPNP=1" "USE_QRCODE=1" denarius-qt.pro
make -j4

After compiling you can create a .dmg installer by running this command in the denarius root (you must have Python 2.7 installed, can be installed via MacPorts)

sudo python contrib/macdeploy/macdeployqtplus Denarius.app -dmg

You have successfully compiled Denarius on macOS!

0. Preparing Your System

As with compiling every project, you need a compiler for the wallet and all the dependencies. Your patience will be tested multiple times duing the build and you have to be ready to spend a good 5 hours or so depending on the speed of your cpu. There are tools you have to install in order to compile. There are a few programs you should have installed to make the process easier here they are:

• 7-Zip for extracting files, choose the option appropriate for your system
• Notepad++ for editing certain files duing the building process

Lets us start with MinGW, you can download it from here. That will download and install the MinGW. Once installed and open you should see a screen like this one:

Click MinGW and Unmark everything, then click MSYS and unmark everything. Then mark the following items under MSYS:

• msys-autoconf-bin
• msys-automake-bin
• msys-base-bin
• msys-libtool-bin

Its okay for other packages to become marked as you make the above, the others are dependencies. Then go to Installation -> Apply Changes -> Apply it will take a minute to download everything

Next you are gonna wanna install the MinGW-builds toolchain from here. While compiling, you are gonna have 2 different cli-type interfaces open, more on that later. Unpack that archive to your drive root, for me that is C:\. Next create a folders in your drive root called deps and Qt. This is where we are gonna compile our dependencies. When all steps completed, your file structure should look similar to mine with all the folders outlined in red:

Next we are going to make sure that the MinGW is in your PATH environment variable. To to this on windows 10, Search environment variable in the search on the bottom. You will get a window and on the bottom will be a button that says Environment Variables. Click it and go to the second list where its says System variables and scroll down to Path:

If you dont see C:\mingw32\bin; at the front, add it in. You may need to reboot your computer to continue this tutorial, one way you can tell is if you open up command prompt and type gcc -v. If it tells you that gcc is an unrecognized program or file, reboot your computer, if not you are good to go and continue. Lastly make sure that the only file in C:\MinGW\bin should be mingw-get.exe. Now to extracting.

1. Downloading and Extracting Dependencies

Here are a list of dependencies for you to download. I suggest downloading each one at a time and immediately starting the next as soon as the former has finished:

1. OpenSSL .tar.gz DO NOT UNPACK YET
2. Berkeley DB .tar.gz DO NOT UNPACK YET
3. libboost 1.57.0 .zip Explorer to deps
4. protoc and libprotobuf tar.gz 7Zip to deps
5. libpng 1.6.16 .tar.gz 7Zip to deps
6. qrencode .tar.gz 7Zip to deps
7. QT Base 5.3.2 .7z 7Zip to QT rename to 5.3.2
8. QT Tools 5.3.2 .7z 7Zip to QT

There are newer versions of QT Base and QT Tools but version 5.13 and 5.12 both have strange errors when attempted to compile. Just use 5.3.2. Once every thing is extracted to your deps folder, it should look like this:

And your Qt folder should look like this:

2. Compiling Dependencies

Finally time to compile, first you are gonna wanna start with OpenSSL. If you remember, I told you not to unpack it with 7ZIP, we are gonna be using tar in the MinGW shell. To open the shell, open C:\MinGW\msys\1.0\msys.bat and do the following:

cd /c/deps/
tar xvfz openssl-1.0.1l.tar.gz
cd openssl-1.0.1l
./Configure no-zlib no-shared no-dso no-krb5 no-camellia no-capieng no-cast no-cms no-dtls1 no-gost no-gmp no-heartbeats no-idea no-jpake no-md2 no-mdc2 no-rc5 no-rdrand no-rfc3779 no-rsax no-sctp no-seed no-sha0 no-static_engine no-whirlpool no-rc2 no-rc4 no-ssl2 no-ssl3 mingw
make

This will change directory to your deps folder, extract OpenSSL, configure and compile it. Next comes Berkeley DB which I also told you not to extract. Do the following in MinGW shell:

cd /c/deps/
tar xvfz db-4.8.30.NC.tar.gz
cd db-4.8.30.NC/build_unix
../dist/configure --enable-mingw --enable-cxx --disable-shared --disable-replication
make

After Berkeley DB finishes, we will build libboost in Windows Command Prompt:

cd C:\deps\boost_1_57_0\
bootstrap.bat mingw
b2 --build-type=complete --with-chrono --with-filesystem --with-program_options --with-system --with-thread toolset=gcc variant=release link=static threading=multi runtime-link=static stage

While libboost is compiling, compile protoc and libprotobuf in MinGW shell:

cd /c/deps/
tar xvfz protobuf-2.6.1.tar.gz
cd /c/deps/protobuf-2.6.1
configure --disable-shared
make

When protoc and libprotobuf are done, compile libpng in MinGW shell:

cd /c/deps/libpng-1.6.16
configure --disable-shared
make
cp .libs/libpng16.a .libs/libpng.a

That last line will rename libpng to a name that qrencode can use. Once done compile qrencode

cd /c/deps/qrencode-3.4.4
LIBS="../libpng-1.6.16/.libs/libpng.a ../../mingw32/i686-w64-mingw32/lib/libz.a" \
png_CFLAGS="-I../libpng-1.6.16" \
png_LIBS="-L../libpng-1.6.16/.libs" \
configure --enable-static --disable-shared --without-tools
make

LIBS sets the libraries for qrencode to compile with. After set, go back to Windows Command Prompt. libboost should be done, if not wait until it is. You shold have renamed the folder QT Base extracts from to 5.3.2, the following requires that it is. Run these commands to compile QT Base and QT Tools. Note* if you have a quad core processor, run all mingw32-make commands with -j4 to speed up the compile time:

set INCLUDE=C:\deps\libpng-1.6.16;C:\deps\openssl-1.0.1l\include
set LIB=C:\deps\libpng-1.6.16\.libs;C:\deps\openssl-1.0.1l
cd C:\Qt\5.3.2
configure.bat -release -opensource -confirm-license -static -make libs -no-sql-sqlite -no-opengl -system-zlib -qt-pcre -no-icu -no-gif -system-libpng -no-libjpeg -no-freetype -no-angle -no-vcproj -openssl -no-dbus -no-audio-backend -no-wmf-backend -no-qml-debug
mingw32-make
set PATH=%PATH%;C:\Qt\5.3.2\bin
cd C:\Qt\qttools-opensource-src-5.3.2
qmake qttools.pro
mingw32-make

*IMPORTATNT* Now that everything is compiled rename the openssl-1.0.1l directory to openssl-1.0.1j. Finally we are ready for the gritty part of the tutorial, compiling Denarius QT

4. Downloading and Compiling Denarius QT

Download which ever version of the repo you want. Beta v3.4 is here, and extract it to whichever folder you like, try to put it in a path without any spaces. the deps folder works just fine. Open up Notepad++ we will need it later. There is one last dependency to compile before we can build Denarius QT, and that is leveldb. It comes packaged with Denarius repo and is located in the src folder of your extracted download. The full path for me is C:\deps\denarius-3.4\src\leveldb. Perform the following in MinGW shell to build:

cd /c/deps/denarius-3.4/src/leveldb
TARGET_OS=NATIVE_WINDOWS make libleveldb.a libmemenv.a

Once compiled you should see somewhere at the end both libleveldb.a and libmemenv.a. In Windows Command Prompt, change directory to your downloaded denarius folder, mine is C:\deps\denarius-3.4, set PATH to include QT Tools and use qmake:

cd C:\deps\denarius-3.4
set PATH=%PATH%;C:\Qt\5.3.2\bin
qmake "USE_QRCODE=1" "USE_UPNP=-" "USE_NATIVETOR=-" denarius-qt.pro

This will configure our build to compile on windows with QT, and QR support and without UPNP and Native Tor. Next you wanna open Notepad++ and edit the Makefile.Release file. Press CTRL+F and search for -levent and delete it. To finally compile Denarius QT, run mingw32-make in Windows Command Prompt and wait: *Note be sure to add -j4 on the end to make it compile faster if you are on a quad core machine!!!

mingw32-make

If the compilation is stuck on a file for a long time, like 50 or so seconds, press CTRL + C very quickly to force the compilation to continue. This may cause an error at the end saying a file with a .o extention is corrupted or missing. Just delete that file and run the above command again. You will know that the compilation succeded when in the release folder of denarius has Denarius.exe in it. My path being C:\deps\denarius-3.4\release. If you have any questions or comments, post them below and I will try to answer them.

Required:
Spreadsheet Software like Excel
Notepad++
Denarius QT Wallet
Some DNR whether its large or small.

First backup your wallet.dat. Now fully unlock the wallet to make this faster. Then create addresses, you will want 500, don't count, just click, push enter many times over and over again.

Make an address and give it a label. We will be sending the entire balance to this one address. I labelled mine armageddon. Now send the entire balance to this address.

Next with your new 500 or less addresses, go to the receive coins tab, and then File -> Export. This will export a .csv file somewhere, make note as we need to open that next. Copy the column with addresses, should be 500. From there we open a new notepad++ text file and paste the column in.

In notepad++ we should have 1 single column of addresses.

On line 1, click at the very first area on the left. Push ALT-C. Text to Insert will be a ". Click OK and this will put quotes down the left side.

Now if your balance is 5000 DNR with 500 addresses we want to distribute 10 DNR to each address. Do some quick math here on your balance and number of addresses.

Click, at the end of line 1, and push ALT-C. Text to insert will be ":10,

":10,

CTRL-A to highlight everything and copy with CTRL-C.

Now you have a text file in proper format, sample here

"WALLETADDRESS":10,

Go back into the QT Wallet to Help -> Debug Window -> Console.

This is a short sample of what to type into the console window.

sendmany "armageddon" '{"WALLETADDRESS1":10,WALLETADDRESS2":10}'

The line will be long, and you may end up with a , at the end. Make sure to delete the last comma before the }.

Push enter, it will distribute your balance to each address and give you a transaction number. Wait 8 hours for coins to mature and get to staking much more with this little trick. I don't think this works with other coins as DNR has a slightly different POS system. Also there seems to be a limit of 500 addresses for sendmany. And you can't do this twice to make 1000 addresses on the same wallet.

Block Explorer
https://www.coinexplorer.net/DNR

After sending, wait for 1 confirm. Go to the transaction tab, right click the transaction, then Copy Transaction ID.

Then go to the Block Explorer tab. Paste the transaction ID from above into the Transaction ID and then click Decode Transaction.

Under Outputs you will see the 5000 D output. The first line is output 0 and the second line is output 1. A sendmany you can have 0 through whatever number. The example below is using that transaction ID and output 0.

First go to your favorite coins repository (repo). In this case Denarius is located on Carsen Klocks personal github. https://github.com/carsenk/

Once we go to the person or coins repo, we want to look for the main wallet. Generally the main wallet will be under a name of the coin. Most of the time the person's repo will also have coin at the homepage, as the homepage on github allows for 6 repos to be pinned. Under this picture I will show the other way to find this.

The other way to find the coin's repo is by clicking Repositories. From here we can see a list of original code and forks the user has created.

The last touched repo will be listed at the top of the repository list. You can also generally type in the name of the coin in the search bar at the top left corner. Examples below to get the feel for this.

Now lets look at the main page of the Denarius repository. Because I have a github account, which I suggest creating, I like to click on watch and star, which once clicked will say Unwatch and Unstar. Think of this as getting the feed for updates, and also liking someones work. The other useful button is Fork. If you click the word Fork you will make an exact copy of the Repo and place this on your own account. If you click the number to the right you can see all of the people who have forked the particular repo.

Two other important areas are below these buttons. You are looking for the latest commit which is on the right side, and a description which is on the left side.

Another important area is the Branch dropdown box. Master is where you generally will start when browsing on your own. The master is typically the main stable branch to use and look through. When a developer is working on their code, they separate out into another branch as to not touch the stable code, and when that other branches code is done testing this gets merged back into the master branch. When multiple developers are working together, they could merge into a version branch, and when all of that is working, the entire kitchen sink of branches then gets merged into the master branch. Hint: most of the coding and commits take place outside of the master branch.

Lets look for something useful, since I am a spec miner and like to solo mine a wallet. So how do we find the rpcport on those coins that ninja release and give no details? Lets try searching the term "rpcport". Denarius thankfully has a nice search to find things, some coins do not. But we can learn something useful anyways. Notice in src/bitcoin.cpp we get a hit for rpcpport? For a moment we can basically not read any code and know its 1 of 2 ports listed. You can then put into your solo miner the port, if that doesn't work you can change to the other number, until one of the ports works. Or you can just name the port in your coin.conf, but that's not what this guide is for. This guide is for searching out something in the repo, finding it and trying something new. Denarius is a fork of an early version of bitcoin, if you do this a few times you will remember generally what bitcoin fork files hold certain information to scan for.

The next thing I look at is the README.md file. The file automatically posts the text and images from this  file, or you can click the README.md file itself. Either way is going to work. We are looking for specs of the coins and any other information that might be useful. Maybe we want to compile the coin? A lot of the time the how to compile is somewhere here. We will get into this in more detail later after doing some more searching through the repo.

Because there is a thing about active development on a cryptocurrency. Lets look at who contributes outside of the coin name itself or the main repo owner. Click Insights at the top of the page.

The Insights page can give us a ton of information for activity, along with frequency of commits, contributors and how all the code ties back together.

Lets look at Contributors. This would be useful as when this article was written, Litecoin was being called out for no activity. Most cryptocurrencies have more than one person writing the code and contributing. In this case we can see that @enkayz has a lot of code himself with ++ and --. What we can see here is that @Carsen is not the only contributor to Denarius. What happens here is that many people contribute into a version of a branch, and then that all gets merged together into a master branch after testing. Was Litecoin active or not? Is Satoshi Lite the only contributor to LTC? Maybe you can go to the Litecoin github and use this guide as a hint book and come to your own conclusion on what's really going on in this space.

Lets check out if Enkayz contributed anything useful. Click commits under his name to go to his work on the project.

We can quickly scan the list of commits to see basic descriptions on what was done. Lets look at his last commit.

The left side is the old code, and the right side is the new code. Red is code removed, and Green is code added. What some coins do to get more commits on cryptomiso is they delete a space and add a space, daily, so the commit count goes up. Randomly putting nonsense into a cryptocurrency is questionable, so try looking through commits to see if more than just spacing of characters is being changed.
https://github.com/carsenk/denarius/commit/d2892124d997c1e15f87a2bdf2dfeff63f1f31fe