Creating a Blockchain Using the Crystal Programming Language

What is a blockchain?

A blockchain is a distributed ledger or database that is shared among various nodes of a computer network. It stores data electronically in digital format. It is best known for being used in cryptocurrency systems like Bitcoin as it provides secure and decentralized solutions for all transactions.

A blockchain helps generate trust without having to worry about a trusted third party. The major difference between a standard database and a blockchain is in the structure of the data: the latter collects information in groups known as blocks that carry a set of information.

Blocks have various storage capabilities that help in filling, linking, and closing blocks with other available ones. There is a chain structure for connecting each block which gives it the name blockchain. Note that a standard database structures its data into tables, whereas a blockchain is structured into blocks.

Important functions of blockchain

Hashing and digital signature

A hash is a function that returns a unique identifier or fingerprint when we provide a text or object. It changes the identifier drastically even when there is a small change in the input object.

Image source: Stack Exchange

There are various hashing algorithms. For this article, we will focus on the SHA256 hash algorithm that is used in Bitcoin. With SHA256, we will always get results in 64 hexadecimal characters in length, even if the input is lower or higher than 256 bits.

Adding just a . (dot) will yield extreme changes in the hash. In a blockchain, the chain is built bypassing the block data into a hashing algorithm that will generate a hash. It is then interlinked to the next block and forms a series of blocks linked with the hashes of the previous block.

Why use Crystal programming language?

Crystal is suitable for programmers who demand more flexibility and better performance. The advanced type interface algorithm can be used to resolve problems when the variable types or methods are mentioned.

Crystal has the added benefit of lowering the learning curve, especially among experienced Ruby developers. Unlike JavaScript or Ruby which are interpreted languages, Crystal is a compiled language, is fast, and has a low memory footprint. It also uses LLVM to compile the native code. Being statistically typed, the compiler helps catch type errors during the compiling time.

How to create a blockchain with Crystal programming language

The step-by-step tutorial below will illustrate the process of creating a blockchain using Crystal.

Setup

The first step to building a blockchain using the Crystal programming language is to install Crystal. Currently, the language supports Linux, FreeBSD, macOS, and OpenBSD operating systems.

Once the compiler has been installed, there will be a crystal binary for usage.

You can create the application using the command below:

crystal init app crystal-blockchain-technology

cd crystal-blockchain-technology

You can add any web framework that supports the Crystal programming language. It will be used when you want to read or write to your blockchain using HTTP requests. You can add your dependencies to the blockchain.yml file.

Next, run the file using the shards install command. Shards are the standard format for program and library distribution. Each shard is held on a different database server instance for spreading the load.

You can now create a data model that will determine how the blocks will look. Rather than crystal-blockchain-technology.cr in the Crystal::Blockchain::Technology module, add what is required.

A global blockchain variable can be defined which will help hold an array of variables. You can declare its type with every key. Feel free to explore different data types to see the array of choices. This will help with the transformation into JSON when you return the blockchain using the GET request.

Each block carries the previous block’s hash to preserve the integrity of the blockchain. This ensures the order of the blockchain. You can create another file inside of src/ called Block.cr which can be made into a module or a class.

You can extend a module with another with the help of the code extend self. To extend a block, use extend Block.

It’s time to add the first method using Crystal. ‘Create’ will help create the block: BlockchainTechnology. These are unchangeable so make use of .merge to add a new key per value pair.

The above example will return a new BlockchainTechnology that will include the fresh pair. It can be seen when you call self.calculate_hash which you can define for the same purpose. This method links the data from the block within a string and hashes it with the upcoming blocks.

One-way cryptographic hashes using the SHA-256 algorithm provide a similar input of any length and make it return a similar output every time. With a hexadecimal presentation, you can hash specific things or the whole library and still arrive at a 256-bit string.

Changing even a single character changes the entire hash. As discussed, hashes help in linking the blocks and preserving the security and integrity of a blockchain. If there are unwanted changes in the blockchain, the hashes will change and shatter the chain to prevent them from spreading.

Building a block and viewing a blockchain

Now, back to crystal-blockchain-technology.cr. You can build your foremost block and pass it into the blockchain. You can interpret an endpoint to read the blockchain in JSON format within your module and inside the blockchain declaration. You can also start over with your server.

A web framework and a block module is needed to add

crystal-blockchain-technology.cr.

require “Kemal”

require “./Block”

Run the following command in your terminal to start the server: crystal src/crystal-blockchain-technology.cr. Go to your browser and type in "http://localhost:3000" to see the blockchain with its first block. Get a browser extension to view JSON if you don’t already have one.

Adding new blocks to the blockchain

Blocks need to be mined before they are attached to the blockchain. The PoW (proof-of-work) technique is commonly used to validate blocks. In PoW, miners compete against one another to validate data transactions on the blockchain and are rewarded. The technique ensures that miners expend the necessary resources for the said validation. It ensures process regulation and speeds up the addition of new blocks.

There must always be one explicit set of blocks in a blockchain at a certain point. If there is a conflict, you can choose the chain that has more blocks and discard the remaining blocks.

Bitcoin follows the same principle. It does this by turning a participant's hash combinations into numerics and alphabets with the block hash ensuring the result will be 0s. You can directly call the numbers with 0s. The alpha-numeric combination will provide a successful prefix of 0s, making sure it is nonce.

When the difficulty is level 4, the entry will have four zeros. The nonce here will be the number when it continues after the zeros. That number will also be the data that is hashed with the block that has produced the level 4 difficulty. You can verify this by running it through the SHA-256 algorithm.

Writing a code on the blockchain

Start by adding two new key-value pairs to the end of NamedTuple declarations which will denote the nonce and the difficulty of the data. You can see the difference when using a 32-bit integer for indexing and showcasing the difficulty level.

In the Crystal programming language, an integer is optionally + or - followed by a set of digits and underscores which may or may not follow a suffix. When there is no suffix, the data’s type will be the lowest integer from Int32 to UInt64 to which the number belongs.

By default, the index and difficulty level will link to Int32 when no suffix is specified. They start with “0” when an unsigned integer is allowed. You can choose the difficulty level from Uint8 to Uint64.

In most cases, a 32-bit unsigned integer will be enough to keep it intact. However, you won’t have to declare the integer type before deciding on the integer to use when creating the NamedTuple.

It’s important to ensure that you include something related inside the create method to connect the methods. You can set the nonce to an empty string and the difficulty level to self.difficulty.

Adding the highest difficulty level to the block module will put pressure on your process. In a functional blockchain, it will be adjusted for regulating the time taken to add a block to the blockchain.

Now, you can add #{block[:nonce]} for the last position in the plain_text interpolation that resides inside the calculate_hash. It will ensure that you hash the nonce with your block’s hash. The next task is to get to the generate method that resides inside the Block.cr.

Within the generate method, call create which will help create the block. Then, begin a loop for looping all the created blocks. Within the loop, pass the present index of the loop’s iteration with a quarrel. It will provide a hexadecimal string that you can merge to the block using the nonce key on each iteration.

You can run the block's hash between each loop using the newest nonce and the loop indicator through the is_hash_valid? method. It will help interpret that method on the block module. Though it will be against the difficulty level indicator, you will still have the correct number of 0s at the start of the hash.

Inside the loop’s generate method, run a check on the solution you have finalized. The results won’t change when you don't increment a variable and perform the operations all over again. You can adjust as many variables as you wish and see what each iteration performs with the same source options. This will let you find similar results and help you determine the difficulty level.

POSTing a new block in the existing blockchain

Go to crystal-blockchain-technology.cr and add a route handler which will help add a block. You will now be able to handle the POST requests for your /new-block and empty down its data from the data key. You can build a new block by processing the previous block on the blockchain combined with the new data.

Before adding the newest block, ensure that the block is not tampered with as there will be data loss which in turn will disrupt the functionality of the blockchain. Once done, you can add the newest method back to Block.cr.

When a new block’s hash is equal to that of the previous one, you should verify if the index is higher than its previous block. In addition, if running calculate_hash with the current block yields an output that is equal to the previous block, that condition is successful. If all the above conditions are successful, you know that the new block has been created.

Next, start your server and go to "https://localhost:3000". You will see your first block there. The code below is the JSON representation of the blockchain to display it to the browser:

[
	{
	“index” : 0,
	“timestamp” : “2022-08-12 00:00:03 - 06:00”,
	“data”: “Block’s data”,
	“hash” : “949578s5fg78s45g5f4s5s4s5s45g4s5s45s44s5s4s5s4s5s4s5s4s5s45sa7882”,
	“pre_hash”: “”,
	“difficulty”: 6,
	“nonce”: “ “
	}
]

You can now add new blocks to the blockchain. Postman will test your API calls.

Provide a POST request to "http://localhost:3000/new-blocks" with JSON body of {“data”: “Newly added data to your second block”}. If all runs smoothly, you will see the new block created and it will respond to the calls from Postman.

When you start adding logs to your blocks, you can easily enter the terminal. And once you do this, it will ensure to print out the failed attempts that occurred during the process of mining new blocks. Once the final output is found, you can print the lucky nonce and the newest blocks in the result.

Now, add a delay in the iterations of the new block being mined. You can also view the blockchain in the browser.

[
	{
	“index”: 0,
	“timestamp”: “2022-08-12 14:45:03 - 06:00”,
	“data”: “Block’s data”,
	“hash”: “56100456450sd45g45sgaysfjhgj45gj5f45gjaa54552jf455jsfhf5j55sa4896h”,
	“prev_hash”: “”,
	“difficulty”: 3,
	“nonce”: “ ”
	},
	{
	“index”: 1,
	“timestamp”: “2022-08-12 14:45:15 - 06:00”,
	“data”: “Some new data to be added in the second block”,
	“hash”: “000ad456450sd45g45sgaysfjhgj45gj5f45gjaa54552jf455jsfhf5j55sabm96h”,
	“prev_hash”: “56100456450sd45g45sgaysfjhgj45gj5f45gjaa54552jf455jsfhf5j55sa4896h”,
	“difficulty”: 3,
	“nonce”: “1lg2”
	},	
{
	“index”: 2,
	“timestamp”: “2022-08-12 14:45:30 - 06:00”,
	“data”: “And, here comes the third block”,
	“hash”: “000ad456450sd45g45sgaysfjhgj45gj5f45gjaa54552jf455jsfhf5j55sabm96h”,
	“prev_hash”: “000fjlhsa554fs5h8f5hf5hf54d62a493h5s63a3575a633g6a5567a7578a9631d4”,
	“difficulty”: 3,
	“nonce”: “zbfh5”
	},
]

Code source: Medium

The hashes following the newest block all begin with three 0s. This will help you modify the difficulty levels and see the changes in the hash. You will be able to see the links between every block’s previous_hash and the prior block’s hash. Note that if the difficulty level is increased too much, it will take a long time to find the final output.

The above tutorial covers the fundamentals of blockchain creation using the Crystal programming language. You can now implement a blockchain from scratch and build an application that will allow users to share information on the blockchain. Once there is a suitable number of blocks and data, you will have a secure blockchain. The project can be launched on different machines to create a network and the final output can be mined