Blog

Preface – This post is part of the Blockchain Basics series.

Introduction

In Blockchain, it is very important to keep our transaction and other data encrypted and secure. The security of data is not a new requirement and there is a whole different department working 365 x 24 for the same. This department is the department of cryptography. Under cryptography, a tree is an organization of data in form nodes and leaves as shown below. Since, it resembles a real life tree, that’s why it is named so. In this article we will explore more about tree and one of its important type i.e. Merkle tree.

What is a Cryptography Tree

A Tree in Cryptographic world is a graphical structure which looks like upside down of a real tree with following features:

• Root is at the top
• Elements are known as nodes
• Lines connecting elements are known as branches
• Nodes without any further children are known as leaves

The above points can be also seen in the image shown below:

Here, Subject is the root. Science and English are the nodes. Physics, Chemistry, Biology, Grammar and Literature are the leaves. The line connecting all of them are the branches.

What is a Merkle Tree

A Merkle Tree, also known as Hash Tree, is a cryptographic tree in which every leaf node contains hash value of a data block, while the non-leaf nodes contains hash of child nodes. Thus the root of the tree is actually the hash of all of its child nodes. This concept was given by Ralph Merkle, hence named so.

Merkle Tree in Blockchain

As discussed above, A Merkle tree in a blockchain is also a representation of blockchain data (in our case hash key of the transaction data) in a form of leaf and child node. All the nodes are ultimately connected to a single root. The root is the representation of all the transaction data stored in the nodes as hash keys into a single hash key. Let us make it simple, a Merkle tree is there with multiple branches and each branch has its own branch. Now the last level of branches will have the transactional data in form of hash keys. These hashed keys will be put into pairs and will be hashed again, as shown in the image below. This process gets repeated until we get only one hash. This hash is then stored in the Blockchain as Data and using it only other data can be retrieved or searched. This high level of hashing makes it tamper proof.

Advantages

• It makes Blockchain Tamper proof
• It makes the blockchain light in terms of space requirement, hence it makes the blockchain fast and light
• It helps to verify the information of a blockchain

Preface – This post is part of the Blockchain Basics series.

Introduction

Whenever a transaction happens anywhere, it is very important to keep the time and date of that transaction in record. This record not only helps in tracing down the transaction for validity but also helps in reducing the number of frauds and maintaining the transaction details in current sequence. To maintain data and time separately is a tedious job. To get rid of this problem, timestamp was introduced which is a mixture of both. In this article we will explore all about it.

What is a Timestamp

A timestamp is a sequence of encoded date and time information almost accurate to a small fraction of seconds. There are many ways to represent timestamps, some are shown below:

Examples:

• Wed 01-01-1999 6:00
• 1995-10-30 T 10:45 UTC
• 1997-11-09 T 11:20 UTC
• Sat Jul 23 02:16:57 1995
• 1256953731 (Unix time)
• (1979-07-21 T 02:56 UTC) –
• 07:38, 11 December 2019 (UTC)
• 1995-102 T 10:15 UTC (year 1985, day 102 = 12 April 1995)
• 1995-W15-5 T 10:15 UTC (year 1985, week 15, day 5 = 12 April 1995)
• 20190203073000 (02/03/2019 7:30:00)

Timestamp in Blockchain

A timestamp in a blockchain is a Date-time value that is stored in a block.  As mentioned earlier, any transaction is incomplete without date and time information. In blockchain, it also tells at which time that block was created. In Blockchain this value is in the form of a Unix Timestamp.

UNIX Timestamp

Unix Timestamp is the number of seconds that have elapsed since 01.01.1970 which means 0000000000 in UNIX time is equal to January 1, 1970 12:00:00 AM.

A timestamp is converted value of GMT. If a block is created, it will take current time of GMT and convert it into Unix Time. Once converted, it will validate it if it is greater than the saved time of previous block. Once validated, then only it is saved. We can convert any time to UNIX time here.

In above figure, you can convert any time to Unix Time-stamp.

How to get Timestamp

Different languages provide different modules and functions to get time-stamp. In JavaScript, we can achieve using the code below:

Date.now()

Advantages

• It keeps the transaction in timely order
• It helps to create a log
• It helps to reduce the cases of frauds

Preface – This post is part of the Blockchain Basics series.

Introduction

Many times you might have transacted money from ATM. That particular transaction results in deduction of some amount from your bank balance and the same amount you might have received from the ATM. This transaction happens at a particular instant of time. This data of amount deduction, the user name or ID and the timestamp together is termed as transaction data. Apart from this, transaction data might also include other important data. In this article we will discuss transactional data in detail.

What is a Transaction Data

Transaction data is a data that includes following information:

• Timestamp
• User Information
• Transaction Information
• Other Relevant Information such as Bank information, location information, security information

Transactional Data in Blockchain

In a blockchain, all the transaction records are saved as a transactional Data. Each block of a Blockchain contains thousands of transactional data and it becomes inefficient to store all the data inside each block as a series of data. This will not only decrease the search efficiency of a data but also increase the size of a block. To solve this issue, data inside a block is firstly converted into a hash data and then stored in the form of a Merkle tree.

Transaction Data in Database

In a database, we have multiple types of information. All information cannot be saved together so there was a requirement to separate these data from one another. All the data that do not change for a long time, like name and educational details, were kept together and were named as Master Data. And all the data that gets updated at regular interval of time, like online shopping data gets updated on regular interval for online shopping websites, then it is termed as Transaction or Transactional Data.

Advantages

Following are the advantages of Transactional Data:

• It helps to create a transaction log
• It helps to maintain correct information of all
• It helps to keep the transaction process simple and stable

Preface – This post is part of the Blockchain Basics series.

Introduction

In the world of database, hashing is a very famous term. Either it is used to sort a table based on hash keys or to encrypt a data using hash function. In this article we will discuss only the second part that in encryption of data. This encrypted data is the actual transaction value stored in a block.

What is Hashing

Hashing in blockchain is an encryption process in which an algorithm is used to convert a string of any length to a string of fixed length. It is a very important aspect in case of Blockchain as it helps us to keep track of huge transaction data without even saving them and rather saves hash of that data. There are various mechanism of hashing, such as Bitcoin uses SHA 256 while Ethereum uses Keccak-256 algorithms respectively. The only important thing to take away from this article is that this generated hash keys are the only that stores data of current block and address of the next block, hence helps in linking both the blocks and also keeping track of the previous block.

How to do Hashing

If you have understood what a hashing is, then you will be thinking how to implement it. Different programing language provide different modules to hash a data. These modules take a data as input and returns fixed length output. The output length depends upon the algorithm used within the module. For example, if the algorithm is SHA-256, then the output length will be 256 bits long. You can find SHA-256 Module for Node.js here.

Example of Hashing

In the diagram shown below, we have generated hash of a string using SHA 256 algorithm and you too can generate hash values from here. In ABAP you can use Method CALCULATE_HASH_FOR_RAW of Class CL_ABAP_MESSAGE_DIGEST to implement SHA-256 encryption hashing.

SHA-256 Conversion

In the example shown below we will write a function in JavaScript to achieve SHA-256 encryption:

var sha256 = function sha256(ascii) {
  function rightRotate(value, amount) {
    return (value>>>amount) | (value<<(32 - amount));
  };
  
  var mathPow = Math.pow;
  var maxWord = mathPow(2, 32);
  var lengthProperty = 'length'
  var i, j; // Used as a counter across the whole file
  var result = ''

  var words = [];
  var asciiBitLength = ascii[lengthProperty]*8;
  
  //* caching results is optional - remove/add slash from front of this line to toggle
  // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
  // (we actually calculate the first 64, but extra values are just ignored)
  var hash = sha256.h = sha256.h || [];
  // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
  var k = sha256.k = sha256.k || [];
  var primeCounter = k[lengthProperty];
  /*/
  var hash = [], k = [];
  var primeCounter = 0;
  //*/

  var isComposite = {};
  for (var candidate = 2; primeCounter < 64; candidate++) {
    if (!isComposite[candidate]) {
      for (i = 0; i < 313; i += candidate) {
        isComposite[i] = candidate;
      }
      hash[primeCounter] = (mathPow(candidate, .5)*maxWord)|0;
      k[primeCounter++] = (mathPow(candidate, 1/3)*maxWord)|0;
    }
  }
  
  ascii += '\x80' // Append Ƈ' bit (plus zero padding)
  while (ascii[lengthProperty]%64 - 56) ascii += '\x00' // More zero padding
  for (i = 0; i < ascii[lengthProperty]; i++) {
    j = ascii.charCodeAt(i);
    if (j>>8) return; // ASCII check: only accept characters in range 0-255
    words[i>>2] |= j << ((3 - i)%4)*8;
  }
  words[words[lengthProperty]] = ((asciiBitLength/maxWord)|0);
  words[words[lengthProperty]] = (asciiBitLength)
  
  // process each chunk
  for (j = 0; j < words[lengthProperty];) {
    var w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
    var oldHash = hash;
    // This is now the undefinedworking hash", often labelled as variables a...g
    // (we have to truncate as well, otherwise extra entries at the end accumulate
    hash = hash.slice(0, 8);
    
    for (i = 0; i < 64; i++) {
      var i2 = i + j;
      // Expand the message into 64 words
      // Used below if 
      var w15 = w[i - 15], w2 = w[i - 2];

      // Iterate
      var a = hash[0], e = hash[4];
      var temp1 = hash[7]
        + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
        + ((e&hash[5])^((~e)&hash[6])) // ch
        + k[i]
        // Expand the message schedule if needed
        + (w[i] = (i < 16) ? w[i] : (
            w[i - 16]
            + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15>>>3)) // s0
            + w[i - 7]
            + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2>>>10)) // s1
          )|0
        );
      // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
      var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
        + ((a&hash[1])^(a&hash[2])^(hash[1]&hash[2])); // maj
      
      hash = [(temp1 + temp2)|0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()
      hash[4] = (hash[4] + temp1)|0;
    }