LearningBlockchains.com

Blockchain verification and validation

2018-01-25T00:00:00+11:00

Blockchain Validation

Blockchain networks can be categorised by the way that new coins are distributed within the network. These different categories are commonly known as proofs. There are many types of proofs and in this lesson, I will go over each one and explain their differences.

Proof Of Work

Anyone on a blockchain that uses proof of work can become what is called a node. Or more commonly known as a miner. These people all keep a copy of the blockchain on their computers. By doing this they help secure the blockchain by having a copy of the ledger. This means that there is hundreds or thousands of people with this ledger, meaning that not one person has it and is in full control of it.

accreditation: Descryptive.com

Proof of work is where these miners are given a hard mathematical problem for their computer to solve. This problem is generating a specific SHA-252 hash. Each block in the blockchain has a block number with a hash associated with it. No one knows what this hash is, So all of the miners are in a sort of race to solve the number, every time a new hash is created it is compared to the block and is either rejected or verified as the correct hash. When a miner verifies the correct has the are rewarded with a certain amount of coins from solving that blocks math problem.

Advantages:

Anyone can be a node/miner
This stops the ability to perform DDOS attacks as it requires some sort of work for any information to be pushed to the blockchain
Everyone who is a node/miner contains a ledger of the blockahin, meaning there is no way to shut it down.

Disadvantages:

Solving these mathematical problems require an insane amount of power. (Currently Bitcoin mining is using more or close to the amount of power used to run New Zealand)
Proof of work in it's current state is unsustainable
Proof of work requires Specific ASCII computers to get any real result, Which consume lots of power and are quite expensive to buy.

Proof Of Stake

Proof of stake is a bit different to proof of work, instead of having miners solving a mathematical problem, people who want to be a node will have to stake a portion of their own money. Then over a period of time blocks are mined as part of the blockchain code, releasing a number of tokens into the system. The people who have staked their coins are then rewarded a portion of the blocks tokens. These nodes still work in the same way as a miner, as in they still approve or disapprove a transaction. However, if they do something within the network that a majority of people do not like, They can lose their stake. Which can be a lot of money.

Advantages:

Proof of stake doesnt require any computer mining meaning no huge power cost.
Nodes have to use their own money, which insures they will do right by the network

Disadvantages:

Whilst this is an advantage as well, It is also a bit nerve racking to stake all of your money into the blockchain.
Anyone can be a node meaning the reward pool is smaller.

Delegated Proof Of Stake

Delegated proof of stake is similar to proof of stake, the difference here is only 21 people can run the network. If you want to become a delegate there are websites in which you need to write up what is essentially a resume. Explaining what you will do for the network and how you will help it to grow. Then the community vote for the delegates they want to see run the network. In turn. if someone wants to change the network it must be put forward to the other delegates and then depending on the blockchain, a % of delegates must agree in a consensus for the change to go ahead. For example in Steem the delegates are called witness's, It requires 15 out of the 21 witness to agree to make a change to the network.

If a delegate starts doing things people do not like or want to change the way things work on their own, people will simply vote them out and then vote in some new people to run the network. This means it is still completely decentralised and fully in the people's control.

Advantages:

Full voting system meaning that the people put who they want in charge.
Doesnt require computer calculations, so there is no power costs

Proof Of Brain

Proof of brain is a new idea in this space. Currently steem is the only user of proof of brain.

The idea of proof of brain is you get rewarded for content you create. Steem is a social network, that allows people to blog, create videos or do podcasts and get paid for it. The better the content the better the reward.

Proof of brain is a very interesting idea indeed. You can now imagine places like Wikipedia using steem so that they can be paid for there work, as they should be!

Hard and soft forks

2018-01-23T00:00:00+11:00

What are hard and soft forks?

In the blockchain world we often hear of these things called forks, and how they are linked to updating or upgrading a blockchain, or even is some cases forming a new blockchain. The question is then what is a Fork and what is it's impact?

In this lesson I will discuss the two types of forks which are, Hard forks and Soft forks.

Soft Forks

A soft fork is when the network decides they want a new feature in the blockchain. This would mean that the new version of the blockchain is fully backwards compatible. What I mean by that is, If someone opted to not update their version of the blockchain, they would still be able to use it as they were before the soft fork, and they would still be able to interact and communicate with the people on the new version. The only downside for them is they wont have the new features that have been updated to the new venison of that blockchain.

Soft forks are for simple small changes that the community decides they would like to implement.

Hard Forks

A hard fork is much more complicated. A hark for is the result of the community splitting up and starting their own thing. We have seen this with Bitcoin and Bitcoin cash, Where a lot of the users in the Bitcoin blockchain wanted to change the way Bitcoin works completely, but a lot of people who were wanting to keep to the original white paper written out by Satoshi Nakamoto and disagreed with the new changes. So Bitcoin Cash was created.

A hard fork is not backwards compatible, once it is upgraded if you havent updated to the new version you will no longer be able to interact or communicate with the people on the new fork, since a hark fork is in-fact creating a new blockchain.

Hard forks are risky because if not enough people move to the new updated version it will become useless and unusable. For this reason a lot of preparation goes into a hard fork set up. Generally people will be given a time frame until the new fork is updated. This is usually set by a block number, Saying the hard fork will happen at block number 50000 for example. At this point, anyone is able to download the new version of the blockchain, however until the hard fork time actually takes place the blockchain will look and function exactly the same as the original fork. The reason for this is to give people time to download the new blockchain and get ready for the hard fork.

Because the new fork is based on the original, all previous transactions are the same on both blocks, in the example of Bitcoin and Bitcoin cash, this means that, if you had 500 Bitcoin when Bitcoin Cash was created you would receive 500 Bitcoin cash. Because in the ledger it says you have that amount seeing that the blockchains run off of the same history. However from that point on you can no longer send or receive coins from either side of the fork.

Summary

Soft forks are for minor updates that the community agree upon, A hard fork is creating a new blockchain from the bases of the original blockchain, because there were enough people who wanted to change the way that particular blockchain worked. Because it is risky to do so and not to mention a lot of work, Hard forks arent very popular in this space. However they do happen and when they do it is always interesting to see what will come out of the fork.

Merkle Trees

2018-01-02T00:00:00+11:00

Ensuring blocks haven't been tampered with

In a bitcoin block, there may be many thousands of transactions. If they were not stored in any particularly clever way, the block itself would always need to store all the information about these transactions. "Full nodes" do this - they store everything. However, for most people this is not sufficient.

For most use cases, you do not need to download the full list of transactions. However, you want to be able to verify it later, if needed. Have a look at our lesson on verifying blocks for more information. So instead of storing everything, you have the option of just downloading the header information. In this header information, all of the transactions are represented by a single hash value. This is the merkle root and is derived from a merkle tree that stores all of the transactions in a bitcoin block.

Let's have a look at one in action. First, navigate to this block's information. The merkle root is 7252b7…781be. The block is made from a whole bunch of transactions, such as this one. If you look at the Input Scripts section of that page, you can see the raw transaction information (this is what is hashed). This is a SHA256 hash, but how is it derived?

Let's consider a simple method of storing the transactions, as a simple list. We take each of the transactions, put them in a list, hash the list, and this gives a merkle root. This alone provides a lot of benefits. If someone changes just one of the values in this list (including simply reording the transactions), the overall hash would change. The resulting hash wouldn't match the one published on the blockchain, and everyone will know something has changed. People can then check each transaction independently to see which transaction has been modified. However, this means downloading all of the transactions to do a verification.

To get around this issue, a merkle tree is used. The procedure is as follows:

The transactions are ordered. The order is up to the miner, who will usually just sort by the highest fees and include those transactions.
Every transaction is hashed using the SHA256 function
The transactions are paired, with transaction 1 paired with 2. Tx 3 with tx 4. And so on…
A pair is then hashed, by concatenating the hashes and then hashing the result. The order of the hashed pairs is maintained.
Each of those hashes is then paired, concatenated and hashed.
Step 5 is repeated until only one hash remains, and this is the merkle root.

The full set of transactions, hashed pairs and so on is the merkle tree.

Benefits

So why bother doing this? We already have looked at a list, which provides the benefit of knowing when things are tampered with. If any transaction is altered, the merkle root changes. Therefore a merkle tree provides the same protection as a simple list-of-transactions. It is at least as good.

Next, if the block has been tampered with, the list-of-hashes approach requires that we download every transaction to verify it. With a merkle tree, we can just download the first level down (i.e. the two hashes that combined to create the merkle root). If the merkle root is different to the published one, then one of these hashes will also be different. We then only need to verify that half of the merkle tree. Further, we can download that hashes "parents" to find out which of those is invalid, further reducing our search space. In effect, we keep looking down the tree, only looking at branches that have invalid values.

With computers, it normally takes longer to download a hash, then it takes to compute a hash locally. This means that we can reduce the amount of network traffic required to find an altered transaction by using a merkle tree.

In summary, merkle trees provide a way for us to verify that the transactions included in a block have not been modified. Those with lower-powered computers can simply download the headers for a block, rather than the full list of transactions. They then know that a block's hasn't been tampered with later on, because they have a record of the merkle root and can verify that. Merkle trees are also faster to use to find any modified data.

Verifying a Block

2017-11-30T00:00:00+11:00

In this lesson, we are going to deep dive into one component of the blockchain, and discover how you can verify, for yourself, a mined block. This gives you assurance that the blocks on the blockchain are legitimate, and that the transactions are appropriately mined. If you do this for all blocks in the blockchain, you can be sure that all transactions in the chain are fair. Open auditing is a great feature!

You'll need to first know what a blockchain is, and what a hash function is.

There are two steps we will cover, over two lessons. In the first lesson (this one), we will cover how to verify the block from the top-level information, specifically the information discoverable in the headers of the blockchain. The main critical part that will be missing from our analysis is verifying the transaction's merkle tree, which we will deal with in the second lesson (coming soon!). For now, we will assume the merkle tree root value is correct. In short, the merkle tree root is a hash of the list of transactions, allowing us to verify the transactions, their order, and their values. If a single transaction in a merkle tree is changed, the root will change, allowing us to see something has been tampered with. (By the way, this has the flow on affect of meaning the nonce doesn't work for the block, and therefore is it not correctly mined.)

Useful Python functions

We will be using Python 3 in this lesson. If you are more familiar with another programming language, the general concepts will transfer over, but I will be talking about some specific python features as well. If you use Python 2, I recommend using Python 3, as it makes the data types more explicit and its more obvious what exactly is happening at each step (but it is a bit more verbose).

First, a slight detour. Python 3 makes a distinction between a bytes object and a string object. A string is a list of character, such as the text you are reading now. A bytes object is a sequence of 1s and 0s. We can choose to represent a bytes object as a string object, which we do with a mapping called an encoding. You may be familiar with ascii, which maps the numbers 0 to 255 to the English characters, punctuation and some other control characters (such as space and the newline character). With this encoding, we can take a singe byte, map it to its character, and show that character in a process known as decoding.

Another encoding is hexadecimal. It takes a four bit sequence and maps it to the characters 0123456789ABCDE, in that order. The bit sequence 0010 maps to the character 2. The sequence 0111 maps to 7, while 1011 maps to B (it's the decimal number 11 and B is the eleventh character in that list).

That's all a little theoretical, let's have a look at it in practice.

s = "I am a string"
b = s.encode("ascii")

print([bb for bb in b])
print([bin(bb) for bb in b])

The first line creates a simple string. The second decodes it into a bytes object. If you print(b), the result will look like the string, except for a b in front of the opening quote. Instead, its just a sequence of 1s and 0s in memory, and when we print it, it uses ascii to represent it. The third line shows a bit clearer what the data structure is like, a sequence of numbers on disk, which are just ones and zeros as shown on by the fourth line of code.

Representing the same integers as hexadecimal in Python 3 requires the binascii library:

import binascii

h = binascii.hexlify(b)
print(h)
print(len(h))

print(int(h[:2], 16))

The output from this shows the hexademical representation of the same numbers. Note they are in "pairs", which is why there are twice as many hexadecimal numbers as letters in the string. The first pair, "49" is the hexadecimal representation of the number 73, which is converted in the last line of the above code block.

Bitcoin, and most blockchains, share their data either in a raw binary format or in hexadecimal format, which you'll be familiar with already, of very shortly after starting to use blockchains. Let's now have a look at a block in detail.

Block 123

You can view information about this block on blockchain.info, but I'll copy the relevant information to this page. The hash of this block is 00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d, which matches the general criteria of "starting with lots of zeros". One small issue is that bitcoin puts its hashes "backwards" by pairs, compared to Python (and many other implementations). This is known as the endianess of the output, and is a topic for another day. The same hash in a "python friendly format" is 1dbd981fe6985776b644b173a4d0385ddc1aa2a829688d1e0000000000000000.

To convert between two strings with hexademical formats, here is a useful function.

def swap_endianess(h):
    if h[:2] == "0x":
        h = h[2:]  # If the hash starts with "0x", remove it
    return str.join("", [h[i:i+2] for i in range(len(h), -1, -2)])

If you aren't familiar with python, this code splits the string into chunks of length two, reverses the order, and joins them back together. You can call it like this:

new_hash = swap_endianess("00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d")
print(new_hash)

Finally, remember what we said about bytes objects? If you actually want to use this in our later code, i.e. to compute the hash-of-the-hash, you need to convert to a bytes object.

g = new_hash.encode("ascii")
print(g)

The type of g is a bytes object (try print(type(g))), and can be put into a hashing function (strings cannot), like this:

import hashlib

h = hashlib.sha256(g)
print(h.hexdigest())

Verifying a Block

Now that the necessary Python is out of the way, let's have a look at how we can use those functions and concepts to verify a block from top-level information. You can see information about the schema on bitcoin.org, but note that it may change in the future. Bitcoin is consensus, not formality, and if the general consensus decides to change, then the format changes.

The linked site specifies the data needed, and the format its in. The main pieces of the puzzle are these:

Version number, as a 32 bit (4 byte) value
Previous block hash, as a 32 byte value
Merkle root hash, as a 32 byte value
Time, as a 4 byte number
nBits, the target threshold for the block as a 4 byte number
nonce, the value that needs to be mined as a 4 byte number

Let's grab the relevant information from the block and then work on changing the format, one-by-one, to the format needed to verify this block's hash.

version = 1
previous_block_hash = "00000000000008a3a41b85b8b29ad444def299fee21793cd8b9e567eab02cd81"
merkle_root = "2b12fcf1b09288fcaff797d71e950e71ae42b91e8bdb2304758dfcffc2b620e3"
time = "2011-05-21 17:26:31"
bits = 440711666
nonce = 2504433986

First, we convert the version number to a four byte hexadecimal number. If we just use the hex function, it will not pad it out to four bytes:

hex(1)  # prints "0x01"

Instead, we can represent it ourselves like this:

version = "{0:#0{1}x}".format(version,4)

Then, we use our function to change the endianess:

# Before: 0x000001
version = swap_endianess(version)
# After: 010000

Next, we convert the two hash values to the required bitcoin format, by swapping the endianess:

previous_block_hash = swap_endianess(previous_block_hash)
merkle_root = swap_endianess(merkle_root)

The next value is the time, which is a little tricky. The string v is just a representation of the time, but we need to find out the timestamp, which is the number of seconds since January 1st, 1970. Timestamps are useful, as they let us represent dates and times as a single integer. This code parses the timestamp:

from dateutil import parser
datetime_object = parser.parse(time)

This code convert it into a timestamp, we work out how many seconds since the 1st of January, 1970 (GMT/UTC).

from datetime import datetime
timestamp_as_int = int((datetime_object - datetime(1970, 1, 1)).total_seconds())

We then convert to hexadecimal and swap the endianess, as we did with the version number:

time = swap_endianess("{0:#0{1}x}".format(timestamp_as_int,8))

The last two values are the required data are just two numbers, and we now know how to convert those:

bits = swap_endianess("{0:#0{1}x}".format(bits,8))
nonce = swap_endianess("{0:#0{1}x}".format(nonce,8))

Each of these now needs to be encoded as bytes objects, and then concatenated together (joined) to form a long bytes object.

version = version.encode("ascii")
previous_block_hash = previous_block_hash.encode("ascii")
merkle_root = merkle_root.encode("ascii")
time = time.encode("ascii")
bits = bits.encode("ascii")
nonce = nonce.encode("ascii")

header_as_bytes = version + previous_block_hash + merkle_root + time + bits + nonce

Finally, we take all this data, convert to bits, and then compute the SAH256 hash twice, which gives us:

import hashlib

block = binascii.unhexlify(header_as_bytes)

round1 = hashlib.sha256(block).digest()
round2 = hashlib.sha256(round1).hexdigest()
verify = swap_endianess(round2)

We can then verify that the result is the same:

assert verify == "00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d"

We are done! If you got an AssertionError, check your code and try again. If nothing bad happened, then the hashest match, and you have verified a block!

Exchanging your coins

2017-11-02T00:00:00+11:00

There are a lot of different cryptocurrencies around at the moment. Of these, there are a few top-tier coins, such as Bitcoin and Etherium. There are many, many others too.

Some of these other coins aim to be the dominant coin. For instance, Bitcoin Cash has features that some claim make it a more useful coin than Bitcoin, and they suggest that everyone move over to Bitcoin Cash instead of using Bitcoin. (It's a heated argument, and not one I'm making a specific recommendation on!) Other coins are specialised, like Golem, designed to be for people to sell their computing power to others.

Regardless of the exact coins, you may want to convert your coins from one coin to another, or even just convert a little at a time. Doing this requires a way to exchange your coins. Most of the time, you do this by converting from your coin to Bitcoin, and then from Bitcoin to the other coin. Bitcoin is chosen due to its dominance in the crypto-world, and its easier to just have one conversion to bitcoin, than between all possible coin-pairs. That said, some websites do provide other direct coin-exchanges.

One such website is the exchange Binance, which allows you to convert between coins on an open exchange. One thing to note is that Binance is an exchange, where you make an offer of your coin and the price you want to sell or buy at. At that point, someone else needs to come along and fulfil that order. As an exchange, Binance records that "I want to sell 3 Etherium for 0.125 Bitcoin". Other people come through, accept that offer and perform the trade. If you are selling for too much, your trade may not find a buyer!

There are other services, like Shapeshift, that simply convert your coins, but they simply just set the price to whatever is needed to do the conversion (i.e. market price, which we will use in a minute), or those services keep a cache of coins for conversion and determine their own price. This makes it nice and easy to use, but it may not be the best price for you!

In the rest of this lesson, I'll go through the process of using Binance to convert coins from one type (Bitcoin - BTC) into another type (EOS). Every exchange will be slightly different, and ensure you are aware of the consequences of your steps before you take them. Remember, you are dealing with coins of value, and mistakes are often very hard or impossible to undo. Take it slowly and carefully!

Step 1: Register

Sign up on Binance with an account. If you want to exchange large amounts, you will need to formally identify yourself, which you can do from your account settings, found on the top right of the screen. After you have registered, sign into Binance.

Step 2: Deposit funds

To exchange, you'll need some initial coin. I recommend Bitcoin as the initial coin as there are more places to buy bitcoin. That said, Binance accepts many different coins.

Click the Funds option on the top navigation bar, and click Deposits Withdrawals. The menu bar is shown below.

This next screen shows all the coins that Binance can accept. Choose your deposit coin (i.e. the coin you already have) and click Deposit.

In the screen below, I had some spare Litecoin and used that coin to deposit.

Copy your address and send the coin from your other wallet. I'm going to use Bitcoin, but be aware that it has high transaction fees compared to other coins. Check Binance's list of coins, compare with what you have or can get, and find a coin that suits you.

Double check the hash before sending, and also confirm you are sending the right coin. As an example, Bitcoin Cash addresses look exactly like normal Bitcoin addresses, and no error will be identified, but your money will not turn up! Check with a local expert if you are unsure - there are many coins that share similar address structures.

After your coins have arrived, you'll have a listed balance in Binance.

Step 3: Trade at Market Prices

Click the Exchange button in the top menu, then choose Basic.

On the right of the screen is a search bar. In this bar, enter the non-bitcoin coin you want to convert to or from.

I'll do two trades in this lesson. First, I'll sell my LTC (Litecoin) for some BTC (Bitcoin), and then I'll also trade Bitcoin for EOS. First, I enter LTC, and LTC/BTC comes up. Click that entry, and it shows the trades for this conversion.

At the bottom of the screen is a tabbed section with the options "Trade" or "Market". If you want to set your price, select Trade. If you want to let the market decide, choose Market.

For this first trade (LTC to BTC), I'll choose Market, which uses the current price of the market. This means the price is set by finding an order that can fulfil your request to buy or sell, and then selecting that price. Sometimes this doesn't happen (i.e. if the price drastically drops just as you put your trade in, or if you are trading a coin with no buyers at the moment).

I want to trade all of my LTC for BTC, and therefore select the 100% option. If you have a specific amount to trade, you can enter that manually, or select as a percentage.

After making your order, if it was a Market order, it is usually performed pretty quickly. You can check by clicking Orders in the top menu, and then Open Orders to seen any incomplete orders. If your order is not there, click Orders again and then Order History to see your order.

Step 4: Trade at your price

If you want to set your price, you need to use the Trade tab we saw earlier. Click Exchange and Basic again to go to the basic exchange screen. Enter the non-bitcoin coin in the search menu (I'm converting my bitcoin to EOS) and select the conversion.

The ticker will show the current price. At the time of writing, the conversion was 1 EOS for 0.00015200 BTC. I'd like to buy if the price dips a little, so I set my price at 0.000145BTC. The order will not process straight away. Instead, it will likely sit in the queue until people sell at higher prices. If the price drops to my offer, someone may choose to sell their EOS for my price.

You need to enter the current price you are offering, as well as how many coins you are buying or selling at that price. In my example, I want to buy 10 EOS and am willing to pay 0.000145 BTC per EOS.

You can see how hard it will be to sell at a given price by checking the depth chart. On the top right of the plot in the middle of the screen, select Depth. The depth chart highlights the cumulative orders at different prices. It has pointed to my price, and it shows all the buy orders that need to be fulfilled that are at higher prices in green and to the right of my order. That's a lot of orders! Learning to read depth charts can give you a sense of how easy or hard it will be to sell or buy at a given price.

That's it on exchanging coins. If you use our referral links to Binance above, half of your transaction fees to to the site, helping us stay up and with new content coming regularly. On top of that, it doesn't cost you any more than usual to do your transactions!

Buying Bitcoin

2017-11-01T00:00:00+11:00

In the world of Cryptocurrencies, Bitcoin (BTC) is the biggest and most known of the coins, So as it stands most other alternate coins (ALTS) are bought using BTC.

As the market grows for BTC so does its value, We have seen just over the last few months BTC go from $5300 USD to $7718 USD. This means people who bought in at around the $5300 mark made a substantial amount of money, this means you can potentially be spending money and still making it!

So how do you buy BTC?

The first thing you need to know is that you do not need to buy a full bitcoin, at the time of writing 1 BTC is worth $6694.02 USD. You can buy as little or as much bitcoin as you want, Putting a few hundred in it is still going to see you make returns and you will still be able to buy anything with the same dollar value of your own countries currency, as long as the place you are buying from accepts bitcoin or B pay.

To get started head to https://www.btcmarkets.net/ and create an account, by clicking on the create account button.

In this process you will need to provide your ID and other personal details to verify your account.

Once your account is created click on account and head to deposit. Here you will be given options to deposit your Fiat which will be used to buy bitcoin. There are many options to send your money through to BTC markets, I personally use POLI.

Once you have found a suitable option for yourself head to the Buy/Sell at the top right hand side of the page. You will come to a screen like this.

Here is where we will buy some BTC!

In the screenshot below we need to provide the Volume and price of what we want to buy.

It is important you understand exactly what these are.

Volume: Is how many coins or % of a coin you want to buy.
Price: The amount you want to buy at.

I'll now show you an example of buying $100 worth of BTC.

1 BTC = $6677.94
Volume:  0.01498 BTC
Price: $6500

What this above example is showing, is the current value of BTC being at $6677.94 , we are wanting to buy $100 worth of BTC. The volume is 0.01498 which Is the equivalent of $100.04 of USD currency. The Price is $6500 which is the price we want to buy the coin at. This means when the price of BTC goes down to $6500 BTC markets will buy our $100 worth of bitcoin at that point.

In this image below I have filled out the information. I am In Australia so the price is slightly different and with the constant change of bitcoin it has, in-fact moved below $100 at this point.

So you can now see you want to buy 0.01498 of BTC at the market price of $3500, and that will cost you $98.19.

When this is completed you will now be able to go to your account and you will see Account summary, Here you should see your BTC listed! Now all you need to do is click withdraw and send your new BTC to your wallet!

Congratulations you have bought your first BTC.

Interacting with the blockchain

2017-10-29T00:00:00+11:00

In this lesson, we are going to take the code we used in building a blockchain, and turn it into an interactive API endpoint using Flask.

If you haven't done the lesson on building a blockchain, it is recommended you go back and do that before doing this lesson.

In this lesson, we will cover these 4 steps.

Implementing a basic proof of work
Making our blockchain an API endpoint
Creating a miner for your blockchain
Interacting with the blockchain

Things we need:

You will need to have Python 3.6 or higher along with pip installed. To install Python click here

Once Python is installed, we then need to install Flask and the requests library.

To install these open up your terminal and type the following:

pip install Flask==0.12.2 requests==2.18.4

Open up your blockchain.py file from the previous lesson.

At the top of your file import all of these

import hashlib
import json
from time import time
from typing import Any, Dict, List, Optional
from urllib.parse import urlparse
from uuid import uuid4

import requests
from flask import Flask, jsonify, request

We will also require a HTTP client, I'm going to recommend postman, as it is an easy to use interface.

Step 1 - Implementing a basic proof of work

Understanding Proof of Work

A Proof of Work algorithm (PoW) is how new Blocks are created or mined on the blockchain.

The goal of PoW is to discover a number which solves a problem. The number must be difficult to find but easy to verify for anyone on the network. The number is made of cryptographic signatures, meaning that if the wrong number is sent somewhere it will be denied access. Thus the PoW algorithm means you can now send money without having to trust anybody or any organisation, as the blockchain only cares about the cryptographic signatures. This is the core idea behind Proof of Work.

We’ll look at a very simple example:

Let’s decide that the hash of some integer x multiplied by another y must end in 0. So, hash(x * y) = ac23d….0. And for this simplified example, let’s fix x = 10.

Implementing this in Python:

from hashlib import sha256
x = 10
y = 0  # We don't know what y should be yet...
while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
    y += 1
print(f'The solution is y = {y}')

The solution here is y = 24. Since, the produced hash ends in 0: hash(10 * 24) = 1253e9373e…5e3600155e860

Just before we add our PoW code, We will need to add some code that will doing the hashing of the block for us.

Here is the code:

 @staticmethod
    def hash(block: Dict[str, Any]) -> str:
        """
        Creates a SHA-256 hash of a Block
        :param block: Block
        """

        # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

If you want to learn more about hashing, check out our lesson on Hashing Functions

The PoW algorithm is what miners race to solve in order to create a new block. The difficulty is determined by the number of characters searched for in a string. The miners are then rewarded for their solution by receiving a coin via a transaction.

Below we will implement our own basic proof of work for our blockchain:

    def proof_of_work(self, last_proof: int) -> int:
        """
        Simple Proof of Work Algorithm:
         - Find a number 0' such that hash(00') contains leading 4 zeroes, where 0 is the previous 0'
         - 0 is the previous proof, and 0' is the new proof
        """

        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1

        return proof

    @staticmethod
    def valid_proof(last_proof: int, proof: int) -> bool:
        """
        Validates the Proof
        :param last_proof: Previous Proof
        :param proof: Current Proof
        :return: True if correct, False if not.
        """

        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

Step 2 - Making our blockchain an API endpoint

Add the below code to the bottom of your Python file. This code turns your file into an API end point. This will allow us to use postman to send/receive requests in our blockchain.

More on Flask API endpoints here

class Blockchain(object):

# Instantiate our Node
app = Flask(__name__)

# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-', '')

# Instantiate the Blockchain
blockchain = Blockchain()


@app.route('/mine', methods=['GET'])
def mine():
    return "We'll mine a new Block"

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    return "We'll add a new transaction"

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }
    return jsonify(response), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Now if you open a terminal in the location of your file, and type python blockchain.py it will start the server.

Now we need to add this below code under your new flask server code. This code will allow you to POST a new transaction over the web to your blockchain.

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    values = request.get_json()

    # Check that the required fields are in the POST'ed data
    required = ['sender', 'recipient', 'amount']
    if not all(k in values for k in required):
        return 'Missing values', 400

    # Create a new Transaction
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])

    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

This is what a Transaction will look like, the user will send this over the server.

{
 "sender": "my address",
 "recipient": "someone else's address",
 "amount": 1
}

we are almost ready to start interacting, all we need now is a way to mine a transaction.

Step 3 - Creating a miner for your blockchain

The below code will create a miner for your server, This will mine and create a new transaction to be placed on a block in your blockchain.

Add this code, below your new transaction code.

@app.route('/mine', methods=['GET'])
def mine():
    # We run the proof of work algorithm to get the next proof...
    last_block = blockchain.last_block
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

    # We must receive a reward for finding the proof.
    # The sender is "0" to signify that this node has mined a new coin.
    blockchain.new_transaction(
        sender="0",
        recipient=node_identifier,
        amount=1,
    )

    # Forge the new Block by adding it to the chain
    block = blockchain.new_block(proof=proof, previous_hash=0)

    response = {
        'message': "New Block Forged",
        'index': block['index'],
        'transactions': block['transactions'],
        'proof': block['proof'],
        'previous_hash': block['previous_hash'],
    }
    return jsonify(response), 200

We will be able to use this code to interact with our blockchain, See it be mined, and then check the chain to see that the transaction has taken place.

Step 4 - Interacting with the blockchain

Start up your server.

python blockchain.py

Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Now open up postman, at the top of postman you will see a search bar. Make sure the button to the left of it is set to GET.

Then type into the bar http://localhost:5000/mine

This is what it should look like.

In this image, we have now mined our blockchain, Which has created our first block. We can see the block number index is 1 and its hash is also 1

Now we can make a new transaction by changing the GET option to POST and typing in http://localhost:5000/transactions/new

(not that this specific blockchain will only do 1 transaction per block at a time)

Finally, we can view the blockchain to now see the new transaction.

Turn the POST command back to a GET and type in http://localhost:5000/chain

you will be displayed with this screen.

As you can see, we now have a new block, It's id'd by It's index "2" It has now hashed the previous blocks hash and has its own proof.

If you look further down, you can see our transaction, we sent an amount of 1 then there is the recipient's address and finally the sender is "0" to signify that this node has mined a new coin.

Success!! You have now built and interacted with your very own blockchain!

This lesson is based on material from https://github.com/dvf/blockchain which has this licence: https://github.com/dvf/blockchain/blob/master/LICENSE

Basics of Security

2017-10-27T00:00:00+11:00

If you are getting into bitcoin and other crypto, you'll need to get at least a basic understanding of security of your system. As the holder of your money, it is up to you, and you alone, to properly secure your private information. As an analogy, consider if you had a bar of gold to store your money. You'll need to secure it, ensuring others cannot access it.

At a minimum, cryptocoins have the following properties you need to consider:

If you lose your crypto, there is no central authority to argue for your money back (as opposed to a bank, where you can often make a complaint).
If you lose your private key, then nobody can access your crypto ever again. Thousands of bitcoins are already lost forever due to this.
If anyone has your private key, they can move your money, acting as if you did. You won't be able to prove they moved the money either.

Due to these issues, you need to take security seriously.

Here is rule #1: Your private key is private. In retrospect, this seems obvious, but it is worth keeping in mind. If you save your private key to your online email, then its possible the owner of the online email can access your crypto (including any hackers who break into that email). If you give it to a friend to keep safe, they have access to your coin. If you use a software wallet, and there is a security issue with the software, your private key may be stolen.

What can you do? Store it in a password encrypted file, remember the password, and make it a secure password. If your password is a 24 word key, you may choose to keep the words, and their order, in different locations.

Rule #2 is to keep your device protected. If you run a mobile wallet, and get malware on your mobile, attackers may be able to access your crypto. If you run a software wallet and you get malware, the same thing can happen. Due to this, be very careful when you are accessing the internet or your email on a device that includes your wallet. The best strategy is to use a different computer or device for storing your bitcoin (preferably one that never touches the internet), than you use for general internet browsing or email. If you do download cracked software or pirated movies, ensure that you never use the same computer for storing your crypto.

Rule #3 is to use encryption whereever it is possible. Every major operating system has a method of encrypting the hard drive of your computer. Depending on the method, you may need to enter a password when your computer starts to access your coin. Sell or trash the hard drive without encryting it is like putting your bitcoin in a bin and hoping nobody goes through the trash. Many people buy old hard drives from trading sites (like Craigslist or eBay) and go through them, looking for private data.

Rule #4 is to follow security tips from software, and seek assistance if you do not understand a step. If a wallet advises you to perform a specific action to secure your wallet, you should (generally) do it. Take as many precautions as possible. That said, if you don't understand the step, check with a local expert first. Most cities around the world are starting to have bitcoin/crypto meetups and you can probably find someone with technical skills to help. (Just don't pass out your private key.)

Rule #5 is to take notes. Some security measures are hard, and your setup is likely to be unique to you. If you have a certain procedure for accessing your coin, make sure to take a note of how to do it. Write down everything except for your private key in a procedure. Keep your private key separate though! The last thing you want is to not be able to access your coin because you forgot how to do it.

Remember, if you get hacked or your private key is leaked, there is no method to claim back your lost crypto, there are no central authorities to complain to, and it would also be quite hard to prove who actually stole your coin. It's lost.

Take your security seriously

Building a blockchain

2017-10-26T00:00:00+11:00

In this tutorial, I am going to show you how to create your own basic blockchain.

If you haven't already checked out our lesson on blockchain basics, I recommend you do that before this tutorial

This tutorial is aimed at people with at least some knowledge in Python.

Things we need:

You will need to have Python 3.6 or higher along with pip installed. To install Python click here

We are going to create this blockchain in 3 steps.

Building a blueprint for the blockchain
Adding a new transaction to the blockchain
Creating new blocks

Let's get building!

Step 1 - Building a blueprint for the blockchain

Open your favorite text editor or IDE, I personally use Pycharm but any editor will do.

Create a new Python file and save it as blockchain.py

Below we will create our blockchain blueprint.

The first step is to create a blockchain class, this class will be an empty list in which we will store our blockchain in.

class Blockchain(object):
    def __init__(self):
        self.chain = []
        self.current_transactions = []

    def new_transaction(self):
        # Adds a new transaction to the list of transactions
        pass

    def new_block(self):
        # Creates a new Block and adds it to the chain
        pass

    def proof_of_work():
       #  Simple Proof of Work Algorithm
       pass


     @property
    def last_block(self):
        return self.chain[-1]


    @staticmethod
    def hash(block):
    # creates a SHA-256 hash of a block
       pass

As you see above most of the defs have a pass in them, Everything we do in this Tutorial will be based on this blueprint, so as we move through the tutorial you will just have to take the new code and replace the PASS section within the corresponding def.

Step 2 - Adding a new transaction to the blockchain

We need a way of adding transactions to a Block. Our new_transaction() method is responsible for this:


    def new_transaction(self, sender: str, recipient: str, amount: int) -> int:
        """
        Creates a new transaction to go into the next mined Block
        :param sender: Address of the Sender
        :param recipient: Address of the Recipient
        :param amount: Amount
        :return: The index of the Block that will hold this transaction
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

After new_transaction() adds a transaction to the list, it returns the index of the block which then sends the new transaction to the block, and will be the next one to be mined. This will be useful later on, to the user submitting the transaction.

Step 3 - Creating new blocks

When our Blockchain is instantiated we’ll need to seed it with a genesis block with no predecessors.

A genesis block is the first block of a block chain

We’ll also need to add a “proof” to our genesis block which is the result of mining (or proof of work). We’ll talk more about mining and proof of work shortly.

Below we will create the new genesis block:

 def new_block(self, proof: int, previous_hash: Optional[str]) -> Dict[str, Any]:
        """
        Create a new Block in the Blockchain
        :param proof: The proof given by the Proof of Work algorithm
        :param previous_hash: Hash of previous Block
        :return: New Block
        """

        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        # Reset the current list of transactions
        self.current_transactions = []

        self.chain.append(block)
        return block

What does a block look like?

Each Block has an

Index
Timestamp (in Unix time)
List of transactions
Proof
A hash of the previous Block

Here’s an example of what a single Block looks like:

block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

We have now created our very own basic blockchain! In the next lesson you will learn how to mine the blockchain and have hands on interactions with your blockchain.

Click here for the next lesson.

This lesson is based on material from https://github.com/dvf/blockchain which has this licence: https://github.com/dvf/blockchain/blob/master/LICENSE

Wallets

2017-10-18T00:00:00+11:00

To use cryptocurrencies, you'll need a wallet to store them in and transact with the blockchain. In our algorithm track, we will go through the algorithms for interacting with cryptocurrencies, but most of the time you want to just be able to spend and receive coins in an easy-to-use manner. This is where wallets come in.

Wallets are programs that contain information on using and transacting for different cryptocurrencies. Some wallets support more than one crypto, while others are specific to just one coin. Additionally, some crypto will be supported by multiple wallets, while others will be supported only on a single wallet.

Further, there are many types of wallets:

Software wallets, that you run on your computer
Mobile wallets, like software wallets but are run on your mobile device
Hardware wallets, with USB-like sticks that store your coins on them
Paper wallets, that print out the relevant information onto a piece of paper
Online wallets, cloud-based software wallets

There are additional options, but that's the standard list most people would use.

Going through the above list, you might be unsure about what it means for a wallet to "store" your coins. In essence, all the wallet really stores is your private key. With that key, however, the wallet is able to make transactions against "your" coins on the blockchain. Think of it like a key to a deposit box at a bank - the bank actually has your things in a box on-site, but you hold the key to get into that box. The blockchain stores your coins, but you hold the key to actually use them.

As an example, when you use a paper wallet, you are really just printing out your private key. We will cover paper wallets in a later lesson, including how to spend from a paper wallet.

We like the following wallets, although we should point out that this doesn't mean they do, or might, have issues.

Coinomi, a mobile-wallet for Android (and iOS coming soon)
Exodus, a software wallet for your computers desktop
ARK wallet, a software wallet for your computers desktop specifically for ARK
MyEtherWallet, a web browser based wallet for Ethereum
Trezor, a hardware wallet that plugs into your pc via USB

When using a wallet, you need to be quite careful to follow the instructions on how to use and secure the wallet. If you lose your private key or password to the wallet, nobody, not even the wallet software's creators, can recover your password or your coins. Follow the instructions closely, and keep an eye out for a new lesson from us on best-practice security.