Peercoin Advanced Relay Subnet (PARS) Node Setup


Project Donation Addresses:
PeerKeeper: PKEEPRnAZCyjC48a4SYH4u4YiPnqt1qoud
PARS: PARSecHDJ2mLw3q18FExaxZcx6AQsWDzrP
PeerScript Labs: PScript9dhNxV5xHGwwcjknh9sxe6s4tVX
PeerAssets: P9uB2bCcbdbzRngJMMAu6aU1XYrdJuQMC3
PeerBox: PEERboxK8o3L45N89RsJ12jY8YEXnexKkT

Visit to talk with the community.


BerkelyDB 4.8.30:

sudo apt-get install build-essential
sudo apt-get install libssl-dev
sudo apt-get install libdb-dev
sudo apt-get install libdb++-dev
sudo apt-get install libboost-all-dev
sudo apt-get install libqrencode-dev
sudo apt-get install miniupnpc

Python, Pandas and Matplotlib 1.2 : Data frames and HDF5 storage

After running into Unicode indexing errors in Python 2.7, a solution was found by installing the Anaconda Python 3.4 distribution. This will also set up your System Environment Variables.

This will be an example that shows you an easy way to capture the ticker data from for all currency pairs. HDF5, also known as Hierarchical Data Format, and Pandas DataFrame will demonstrate to be powerful for quick analysis on large data-sets.

After you have installed the distribution, open the Anaconda Launcher:


Launch an ipython-notebook. A new window should open directed towards localhost:8888/tree or  similar. Under files go to the new button and select “Python 3” under the notebooks section.

To begin, import pandas and the time library by doing the following:


Also, set a variable named url  to be the BTC-e api ticker url. In this instance we are concerned with capturing data for each pair available on BTC-e.

Next will be the soul of our data capturing, pd.read_json() .


I recommend setting the delay to time.sleep(2). If you read the API information on BTC-e, it states that it refreshes at 0.5Hz.

We simply read the json from the api url into a data-frame named frame and transpose it. Next, we define keylist as the values of the index (pair names for ex. ‘btc_usd’ to be used as the data-frame key); of which is accomplished by setting keylist = frame.index.values.

In the for loop we then separate out each pair with its index set to the series ‘updated’. We then use store.append(‘key’,data) to append each key and data-set to pd.HDFStore(‘filename.h5’).

Once you stop the loop, you can view the data with the follow:


Type any pair combination on BTC-e as the key such as ‘ltc_usd’ or ‘ppc_usd’ to get the logged data.


Here’s a quick example of plotting the data.


Next we will learn about real time plotting using matplotlib!  

Python, Pandas and Matplotlib 1.1 : Analysis and Storage of Large Time-Series Data from the BTC-e API

First off I would like to thank Wes McKinney for his great work compiling together the pandas library over the past years. His book Python for Data Analysis (~$25 on Amazon) is fantastic and a great addition to your home library.

This post will be an introduction to help you better understand the resources and tools available to you in python and the pandas library. If you have been following the MATLAB data capture tutorials you will transition into these python tutorials fairly well.

Our main objective is to capture the JSON data from the BTC-e API and continually store and analyze it to our liking. To accomplish this we will be utilizing Data Frames (Not to be confused with the Data Frames found in “R”) and Hierarchical Indexing.

Now, I started off hacking away in Python 2.7 with the following Libraries/Packages/IDE:

  • IPython
  • Pandas
  • Matplotlib
  • Spyder
  • Numpy
  • SQLite3

I recommend downloading the following Python(x,y) Package.

It will provide you with the following:

  • IPython 2.4.1-10
  • Pandas 0.16.2-15
  • Matplotlib 1.4.3-7
  • Spyder
    • If you’re comfortable working in the MATLAB environment the Spyder IDE will feel like your home away from home.
  • Numpy 1.9.2-8

Our main working environments will be the Spyder IDE along with instances of IPython Notebooks. I have found that this is a great combination for testing out new strategies.

Once you have accumulated the necessary resources for this tutorial continue on to Part 1.2. If you have any trouble feel free to leave comments or contact embeddedthought directly.

Preview of What’s to Come: Neural Network Trading on BTC-e


Sorry I have been taking so long to post with updated information.
With the market exploding like it is I have been using my time
to continually refine and develop the bot. This project will be expanding
into a collaboration between myself and other developers. Perhaps it might be
best to wait and provide you all with a walk-through of the finalized bot
since it is ever evolving.

Thank you for reading!


Considerations before starting Part 2:

I will not be going in to full detail on every step and I will be assuming you have a basic understanding of MATLAB. Feel free to leave a reply if you have any questions.

Example of recording order-book movement through time:

After Part 2 we will have the functions necessary to start capturing useful data.


Capturing Data:

Initially, we want to have our data constructed in a way that will be easy for us to use and manage.

To start, I have created a main function to initiate when we want to record the status of the order-books and the corresponding price fluctuation. retreiveorders

There are 3 sub-functions that pertain to the three pairs I am collecting order-book data on.

We will get started by creating those first.

ltcbtc_orderbookMovement does the following:


Every function underlined in blue you will find in the BTC-e Trading API link I referred to in part one. I underlined urlread2 to emphasize that it needs to be in the same folder as all of the BTC-e API files and functions (Which should be the directory you’re working from).

On the last line we are simply converting the incoming information from a structure  to a data-set.

Continuing ltcbtc_orderbookMovement :


During the for loop we are using strcmp to separate the two types of orders, ‘ask’ and ‘bid’.

We are allocating the ask orders and bid order to individual output cell arrays. After doing so, we then use cellfun to remove all empty cells in the array. This is important because we will be concatenating this data with whatever it was previously. If it is your first time running the function and you do not have variables set up, don’t worry. The following rest of this function will take care of that.

Continuing ltcbtc_orderbookMovement :


The double save is redundant and unecessary.

Now that you have an idea on how we want the incoming information structured, you can go ahead and create two more of these function for BTC/USD and LTC/USD. Rename the variables however you please but make sure to check line 34 and change “orderbook=dataset.ltc_btc;” to which ever pair you’re waiting to gather data from.

This process can also be repeated to create the function priceHistory() referenced to at the beginning of this entry. Just change the necessary information to pull from the function realtime_ticker() referenced to in Part 1.

Now that data gathering is out of the way. We can get to the fun stuff!

Any and all tips are greatly appreciated.

Part 1: MATLAB, Neural Networks and the BTC-e trading API.

Let’s get started:

This might contain around 5 parts, so here we go..


I’m in the beginning process of developing a trading-bot using Matlab. Right now the plan is to save data concerning what the order-books look like before and after a dump. This data will be used for training the Neural Network through identification using pattern recognition.


Multiple indicators will be incorporated as input data also, but we will save that part for later.

The bot needs to have an understanding of order-book trends and the following implications to the price.

A Brief Walk-through on Data Retrieval:

The data is sourced from the BTC-e Trading API

(You will find the need to add urlread2 to your project folder in MATLAB).

urlread2 can be found at the following:

Trading API for MATLAB at the following:

Here is a list of all possible requests:

% response = GetInfo()
% response = TransHistory()
% response = TradeHistory(‘count’,2)
% response = ActiveOrders()
% response = Trade(‘pair’,’btc_usd’,’type’,’buy’,’rate’,200,’amount’,1)
% response = CancelOrder(‘order_id’,651389)
% ticker_output = realtime_ticker(‘btc_usd’);

The default amount is set to only retrieve 150 listings in the orderbooks, whether they are bidding or asking.

We definitely want to get a larger data set than 150 listings. The reason being is that we are going to be creating an Artificial Neural Network and training it with this data. The larger the data set, the better life we all live. The maximum limit for the GET method from BTC-e is 2000 listings. So we’ll go ahead and use that.

To change that we make our own function to change the get method limit to ‘2000’:


You don’t have to do it like this, but this is just one way.

I’ve been recently recording the history of order-book movement for the  LTC/BTC pair.


While resting at a somewhat steady exchange rate of 0.0076 for a few days, we recently witnessed a dump to around 0.0073. Having said that, take a look at the order-book movement through the dump. We will be collecting this data to train the bot to recognize a dump before it happens.



Let the dump begin:

dumpltcbtc dump

Bid Volume starts increasing:


The Recovery stage:


I will have a break down on gathering and allocating the data to the neural network in part 2.

Thanks for reading!

Any and all tips are greatly appreciated.