DEV Community: Darko

How to detect weekly crypto winners

Darko — Mon, 01 Jun 2020 13:37:31 +0000

In this article we’ll go over a few scenarios and code examples about how to track the biggest winners within the crypto market in a short period, a week or a month.

You can inspect the coins you are actively trading in, you can explore among the different Bitcoin markets or you can track the top 20 coins by marketcap.

Using the BitcoinAverage API all of these scenarios can be easily achieved.

We will define crypto winners in few categories:

Highest relative price increase, in percents.
Highest absolute price increase, in us dollars.
Highest market cap increase.
Highest 24h trading volume increase.

Highest price increase

To calculate the highest price increase we need to fetch both the latest ticker price and the historical price that we are interested in.

My list of coins will be: Bitcoin(BTC), Ethereum(ETH), Litecoin(LTC), Ripple(XRP) and Monero(XMR).

Latest ticker price

The latest ticker price for one coin can be retrieved from the BitcoinAverage ticker endpoint: https://apiv2.bitcoinaverage.com/indices/global/ticker/BTCUSD

This is the global Bitcoin price calculated by averaging all Bitcoin trading markets, including BTC/USD, BTC/EUR, BTC/GBP etc..

If you are interested only in the BTC/USD market, you can get that with our local ticker endpoint: https://apiv2.bitcoinaverage.com/indices/local/ticker/BTCUSD

In our case we want to get ticker price for 5 coins at once, we can do that with the “all” endpoint: https://apiv2.bitcoinaverage.com/indices/global/ticker/all

Here is a code in Python on how to get these prices:

You will receive a lot more data than you need to, this is the full ticker response for one coin, you will receive a dictionary or a map of these, represented like: {BTCUSD: {ticker response}, ETHUSD: {ticker response}

As you can see we already keep track of the price changes for hour, day, week, month, 3 months, 6 months and year periods. But with this tutorial you can track the price changes for a specific period of your choosing.

From the ticker response we will be using only the “last” price and the volume.

History price and circulating supply

We can retrieve the history price at a single point in time or in a time period.

For our example we’ll be getting the price at a single point in time, 7 days ago from today.

The History endpoint we’ll be using is:

https://apiv2.bitcoinaverage.com/indices/global/history/BTCUSD?at=timestamp

The actual code:

Here we must make a separate call for every coin and the response will be as bellow.

As you can see we have the full OHLCV response here for May 15th. Today we are going to use only the average price and the volume.

You will notice a second function called get_coin_supplies. We use this one to get the metadata that contains the market cap, total supply and circulating supply. We will use the circulating supply to detect which coin had the biggest market cap movement.

Our calculation for market cap will simply multiply the price by the circulating supply.

Calculating and sorting winners

Once we have all the data we need we can write the algorithm for calculating the price, volume and market cap changes and sort the results.

For calculating the price difference we just subtract the latest ticker price from the history price. We do the same thing for the volume.

For the market cap difference we multiply the circulating supply by the same price difference.

Finally we are sorting by the absolute price difference by specifying the key argument to the sort function with operator.itemgetter(1)

If you’d like to sort by relative price, set operator.itemgetter(2), to sort by volume pass in operator.itemgetter(3) and by market cap operator.itemgetter(4).

If you find this useful or interesting let us know in the comments.

If you have other ideas you’d like to implement with live and historical crypto data you can contact us at info@bitcoinaverage.com and we’ll be happy to help.

Efficient way to calculate a moving average

Darko — Mon, 18 May 2020 08:55:26 +0000

The moving average figure is part of the most popular trading indicators. It provide reliable and important information about the state of the market we are tracking.

Benefits of moving averages

Instead of tracking the price movement only by the latest price, which is only one point, the moving average is tracking the average movement in a full period, taking into consideration the last n points.

If you’re calculating daily average, that is the average price movement in the last 24 hours, this is taking into consideration all price points from the last 24 hours.
This makes the moving average a more reliable indicator of the price movement that is not easily swayed by one or two trades.

Usages

The moving average is part of many trading strategies. One of the most common signals is tracking two distinct moving average windows and detecting the points of their interceptions.

For example tracking the short 5 days and the long 30 days averages. When the short moving average crosses the long moving average that indicates these is real price movement in the market.

Calculating Moving Average
Example: Let’s consider having the following 5 prices, one per day, that we want to calculate moving average.

Day1: 5000
Day2: 5390
Day3: 5500
Day4: 5400
Day5: 5700

If we are calculating moving average with size of 5, we would calculate the average from all 5 days from above:
Sum = 5000 + 5390 + 5500 + 5400 + 5700 = 25000
Count = 5
Moving average = 25000 / 5 = 5000

When we receive a price for Day6 we would need to sum the day prices between Day2 and Day6 and again divide by 5 to keep the moving average moving forward.

The Efficient approach

At BitcoinAverage we are keeping moving averages from 24h up to 1 full year. In this case we have a lot of price points to sum up which is quite inefficient considering that only few price points come in and few expire.

There is also another challenge which is that sometimes there could be 5 new price point per calculation and other times 10, so the count of the numbers need to be adjusted as well.

The approach we came up with is the following:

Keep a moving sum and moving count of all price points
When new price points arrive, update the sum and the counter
When price points expire, remove them from sum and decrease counter
To calculate the average just divide the moving sum by the moving counter.

Example

Let’s start with the price points: 5001, 5002, 5003, 5004.

We keep the sum and the count of these numbers:

Sum = 20010

Count = 4

Then we receive two new numbers: 5010 and 5008, now are full list looks like this:

5001, 5002, 5003, 5004, 5010, 5008.

If we are keeping a moving average based on the number of price points, in this case 4, then we need to include the two new numbers and remove the two oldest ones.

What we do is just subtract from the sum the expired ones and add in the new ones.

Sum = 20010 – 5001 – 5002 + 5010 + 5008 = 2025

The counter stays the same, 4.

However most often you will need to keep a moving average based on a time window, for example 24hours. And you will be calculating the average on a different interval than the prices are ariving.

For example new price points could be arriving every second, but the average will be recalculated every minute. This is the case with any trading market, there are new prices every second.

So at the point of updating the moving average you could have 15 new prices and only 12 expiring prices, which would alter your counter value.

The first thing to do is to keep your price points sorted by their time of arrival, the easiest format to keep track of arrival time is by timestamp,

Timestamp for a specific date is a number that represents the number of seconds passed since 1970 until that date and time.

Without further due here is a complete gist example in Python:

FocusHub | Productivity Social Network for the greater good

Darko — Fri, 08 May 2020 04:18:16 +0000

Wouldn’t it be fun if we could socialize, have fun, connect with our friends or meet new friends around our interests and experience awesome productivity at the same time?

Of course it would be. But the social networks out there are designed to turn you into a consumer zombie, grab your attention and keep it as long as possible. Scrolling mindlessly through the endless stream of videos, pictures, stories, tweets, pins…

There is a much greater opportunity here. We are social beings, that’s a fact and that is great. That is how we survived for thousands of years, in tribes, by staying connected and getting better together.

That is the true power of social networks.

And we can use it to our advantage.

The purpose of Focus Hub

What if there is a social network that helps us achieve more, be more productive and create better lives for ourselves?

What about a social network where instead of posting pictures of your food everyone shares what they’ve accomplished today.

What if you could work alongside other like-minded people who are focused on making it in life and achieving their goals.

FocusHub is a social network that provides an environment that encourages productivity and it provides the tools for getting into Flow and getting things done with efficiency.

Environment

The Productivity feed at FocusHub allows you to share your major and minor daily accomplishments and completed tasks. Place to share your small daily wins and participate in a friendly competition with the daily scoreboard of minutes worked and tasks accomplished.

Imagine you are hanging out with bakers all day, people making bread. In a while you’ll know quite a lot about making bread.

At FocusHub you’re around people interested in productivity, high performance and achievement, just by being there, the productivity will rub off.

Focus Sessions: strategy for maximum efficiency and flow

Focus Sessions make FocusHub a hybrid between a social network and a productivity tool.
They help you actually get things done and get into flow more easily. Focus sessions allow you to create customizable work cycles with short breaks in-between.

For every work cycle you have to define three things:

The task to accomplish
First concrete steps on how to get started with the task
Anticipate blockers
Defining all of these, combined with the time limit will force you to laser focus and achieve much more in that time period.
Also knowing you have a break afterwards will allow you to put off any distractions, emails, phone calls and get to them as soon as your cycle is over. Anything can wait a few minutes.

I usually work in 30min work with 5min breaks work intervals for normal tasks and 50min work with 10min breaks for deep work in the morning.

You can explore FocusHub at: https://thefocushub.net

See you on the productive side.

PS: You can reach me at darko@thefocushub.net for any suggestions, bug reports, questions or productivity advice.

Project management sprinkled with productivity and a dash of self-improvement

Darko — Thu, 25 Apr 2019 13:16:35 +0000

The vision of combining project management with productivity and self improvement.

Self improvement: Become more capable to do the work

Habits: Adopt healthy habits to have more energy, healthier body and mind that can accomplish more in less time

Journaling: is only helpful if you do it consistently. Record your daily activities, the parts that matter to you at least, and then review your daily journals every week into your weekly journal.
This is the fastest way to detect if you are spinning your wheels being busy and not going anywhere or you are on the right path. If moving forward, notice if it's the right direction and course correct if needed.

Project management: Organize the work

Everything can be set as a project, losing weight, building a business, starting a podcast, organizing an event.
Any goal that you have, once you make it concrete, becomes a project.
Organize your goals into projects with specific tasks, deadlines and documents.

Use the master list every night to plan the tasks for the next day.

Productivity: Do the work, more focused and productive

Use the advanced pomodoro cycles to work in small focused work periods. Smaller periods are easier to guard against distractions and to get focused.

Who is it for

Obviously anyone can benefit from becoming better, getting organized and working faster.

But not everyone will do that. Some people are lazy and others can’t get out of their current routine. Others already have a system that’s working for them and that is also fine. It is important to know who your product is not for as well.

Two groups of people will benefit the most out of LifeHQ

Group 1: You have a system but it’s broken

Usually the ones that already have a system are people who know that productivity, organization matters and they have things going on in their lives.

Entrepreneurs and Freelancers

People working for themselves and trying to get their business off the ground.

They have tried a lot of productivity apps and tried to combine them into a system for managing their lives.

Probably have 3 or 4 different apps but end up using only the ones they have to, the ones with the actual work. All the habits, journals and pomodoro apps are forgotten after a few days, because they are nice-to-haves not must-haves.

LifeHQ solves this problem by luring you in with the project management module but once you’re there it is so easy to write your journal, check off your habits and spin a few work cycles.

Group 2: No system whatsoever

In this group I will put students but also anyone that is in a new environment and wants to prove him or herself.

Students at the beginning of their studies need to prove themselves in College or University.

Students at the end of their studies beginning their first job must prove themselves in the new workplace.

They will understand LifeHQ much easier because they have no previous bad patterns and experiences with productivity systems.

Proactive software

Proactive software goes beyond mere functionality.
It helps you become a power user as quickly as possible.
As a result you get the benefits that you signed up for much sooner: productivity, organization and consistency.

How LifeHQ is proactive

LifeHQ is built as an out of the box system ready for use in 2 minutes.
All 4 types of journals have different templates so you are never caught staring at a blank screen not knowing what to write.
LifeHQ knows what you need to accomplish today and offers morning, midday and evening reminders that notify you what is left for the day.
When you login for the first time you already have a project created with real tasks for personalizing your system with your goals, projects and habits.
Introductory tours: All modules have introductory tour that explain everything you see on every page.

To skyrocket your productivity, finish your projects and simply accomplish more try out LifeHQ for free.

The easiest way to track your Bitcoin profits

Darko — Tue, 23 Apr 2019 10:50:42 +0000

We often find ourselves checking the bitcoin price multiple times a day, waiting for the next peak or valley. We all want to make some profit from the market volatility.

Often times this becomes distracting and time consuming, but not anymore. Let's build a script which automatically checks the price at your favorite exchange, compares it to your starting price and notifies you of the profit you are making.

Quick Start Guide

If you just want to run the script without digging into it you can get the final code from here. Then just copy and paste it into a file with “.py” extension and run it via terminal:

$ python bitcoin-profits.py

The script will prompt you to enter some data.

Your exchange: the exchange you want to check at, this is the exchange where you plan to sell the bitcoin eventually, or just your favorite one.
Bitcoin starting price: The price at which you bought your coins.
Bitcoin amount: The amount of bitcoin you bought at that price.
Your currency (default USD): The fiat currency in which you are trading.
Check every (seconds): The script performs the calculation in an infinite loop, so this parameter specifies how much to wait between subsequent executions. You can choose from 4 options for our API.
Choose to be notified when a certain limit is reached: 1) Percent limit, 2) Amount limit. Here you specify when you want to be notified of the change in price in Bitcoin. If you choose the first option (1), then you will be asked to enter the amount of percent. Say you enter 10, this means that when the price of Bitcoin changes 10% from your starting price, you will receive a notification. The second option allows you to specify the exact amount, here if you enter 10 you will be notified when the Bitcoin price deviates 10 US dollars form the starting price (assuming US dollars is your currency).

Full Developer guide

Step 1: Generating the BitcoinAverage API key pair

To be able to generate a key pair you must have an account at BitcoinAverage. Choose one here

After you create and verify your account you can generate the API key pair here.

We have a complicated authentication method and a simple one.
Let's use the simpler one here. Just copy the public key and put it in a header in your request.
Header

x-ba-key: <your public key here>

Step 2: Making the Http API call to the BitcoinAverage API

def main(exchange, starting_price, amount, currency, limit_type, limit):
    """
    :param exchange: The exchange where bitcoin was bought
    :param starting_price: The price at which bitcoin was bought
    :param amount: The amount of bitcoin
    :param currency: The currency bitcoin was bought in
    :param limit_type: The type of threshold, percent or amount
    :param limit: The value of the threshold
    :return: Current profit made
    """

    API_ROOT = "https://apiv2.bitcoinaverage.com"

    response = requests.get("{api}/exchanges/{exchange}".format(api=API_ROOT, exchange=exchange), headers={'x-ba-key': <your public key here>})
    symbol = 'BTC'+currency
    latest_bid = response.json()['symbols'][symbol]['bid']
    result = calculate_profits(currency, latest_bid, starting_price, amount, limit_type, limit)
    return result

This is the main function that accepts all of the parameters entered by the user and forwards them to the calculate_profits function which we’ll write next.

But before we start coding make sure you have the awesome requests http library installed. Get it with: pip install requests.

Let’s checkout the response we get from our API real quick.


{
    "name": "bitstamp",
    "display_name": "Bitstamp",
    "url": "https://bitstamp.net/",
    "timestamp": 1493816831,
    "data_source": "api",
    "symbols": {
        "XRPEUR": {
            "last": 0.0513,
            "volume": 5706005.4795,
            "ask": 0.0513,
            "bid": 0.0511
        },
        "BTCUSD": {
            "last": 1474.74,
            "volume": 9207.05,
            "ask": 1474.70,
            "bid": 1471.81
        },
        "BTCEUR": {
            "last": 1345.10,
            "volume": 1032.09,
            "ask": 1347.59,
            "bid": 1345.10
        },
        "XRPUSD": {
            "last": 0.0560,
            "volume": 12515723.6935,
            "ask": 0.0560,
            "bid": 0.0557
        }
    }
}

As you see from this response you can discover all the available trading pairs at your exchange and you can extend this script to perform the profits check calculation on more than one trading pair.

For now we will only use the BTCUSD values from the response.
Let’s cover what these values mean: ask, bid, last and volume.

Last: the last price at which Bitcoin was sold or bought
Bid: the best (highest) bid. The highest price someone is willing to buy Bitcoin at your exchange right now.
Ask: the best (lowest) ask. The lowest price someone is willing to sell Bitcoin at your exchange right now.
Volume: the total number of Bitcoin bought and sold at this exchange in the last 24 hours.

From these values we are only interested in the “bid” value because if we were to sell our coins right now, that is the price we would get for them. so after we extract the bid, we just pass all the values to the calculate_profits function.

Step 3: Algorithm for checking our profits

def calc_percent_diff(now, base):
    difference = now - base
    return difference * 100 / base

def calculate_profits(cc, latest_bid, starting_price, amount, limit_type, limit):
    difference = abs((latest_bid - starting_price) * amount)
    single_diff = latest_bid - starting_price
    if limit_type == 'percent':
        percent_difference = calc_percent_diff(latest_bid, starting_price)
        if percent_difference >= limit:
            return "The bitcoin price has increased by {:.2f} %, you have a profit of {:.2f} {}\n That is {:.2f} {} per coin.".format(percent_difference, difference, cc, abs(single_diff), cc)
        elif percent_difference <= -1 * limit:
            return "The bitcoin price has decreased by {:.2f} %, you have a loss of {:.2f} {}\n That is {:.2f} {} per coin.".format(abs(percent_difference), difference, cc, abs(single_diff), cc)
    else:
        if single_diff >= limit:
            return "The bitcoin price has increased by {:.2f} {}, you have a profit of {:.2f} {}\n That is {:.2f} {} per coin.".format(single_diff, cc, difference, cc, abs(single_diff), cc)
        elif single_diff <= -1 * limit:
            return "The bitcoin price has decreased by {:.2f} {}, you have a loss of {:.2f} {}\n That is {:.2f} {} per coin.".format(single_diff, cc, abs(difference), cc, abs(single_diff), cc)

What we are doing here is comparing the starting price with the latest bid price we got from the API.

If the script is setup to check in percent, we are doing that, otherwise we are checking for the absolute difference in dollars between the two prices.

If the latest price has deviated from the starting price more than a certain amount then we are constructing a helpful message that we will present to the end user.

Step 4: Running the script in an infinite loop and displaying desktop notifications on Linux and Mac

if __name__ == '__main__':
    my_exchange = input("Your exchange:")
    starting_price = input("Bitcoin starting price:")
    amount = input("Bitcoin amount:")
    currency = input("Your currency (default USD):")
    check_every = input("Check every (seconds):")
    threshold = input("Choose to be notified when a certain limit is reached\n1) Percent limit: \n2) Amount limit: \n ")
    limit_type = None
    limit = 0
    if threshold == '1':
        limit_type = 'percent'
        limit = input("Percent:")
    elif threshold == '2':
        limit_type = 'amount'
        limit = input("Amount:")
    if not currency:
        currency = 'USD'
    notifications = input("Choose desktop notifications: \n0) No\n1) Mac\n2) Linux\n")
    while True:
        result = main(my_exchange, float(starting_price), float(amount), currency, limit_type, float(limit))
        if result:
            if notifications == '1':
                content = 'display notification "{result}" with title "Bitcoin Profits" '.format(result=result)
                subprocess.run(['/usr/bin/osascript', '-e', content])
            elif notifications == '2':
                subprocess.run(['notify-send', 'Bitcoin Profits', result])
            else:
                print(result)
            break
        time.sleep(int(check_every))

First we’re getting all the data we need from the user and then using infinite looping (while True:) we are executing the main function from before.
If this function happens to return us some answer, that means there is something to show to the user.

Depending on his choosing either Linux or Mac desktop notification will be generated. If he hasn’t chosen notifications, or is a Windows user, the message will be printed in the terminal.

Linux desktop notifications

I have only tried this on Ubuntu Linux, so these might not work on other Linux distributions. The library for generating notifications is called notify-send and it’s very simple to use. In our example above I am running it like this.

notify-send 'Bitcoin Profits' result

This will show the result as the body of the notification and “Bitcoin Profits” as the title.

Mac desktop notifications

osascript -e 'display notification "You have made 10% profit" with title "Bitcoin profits" '

Full code

The full code for the script can be found here: https://gist.github.com/KolevDarko/e4e57825871c89adfaf0bf09eded3b45

If you have any questions about extending this script or doing something similar feel free to ask in the comments.