DEV Community: Jyotirmoy Barman

Blockchain Storage

Jyotirmoy Barman — Mon, 27 Feb 2023 18:05:21 +0000

To understand the storage system on blockchain we need to first understand what we store in the blockchain. My previous Blockchain Structure explains this.

%[https://jyotirmoy.dev/blockchain-structure]

Introduction to blockchain storage

The blockchain contains some data, such as transactions or other information, and a unique code, called a hash, hash is generated based on the contents of the block. The hash is used to identify the block and ensure its integrity.

One of the popular blockchains is Ethereum, it can store data, including images, but it is not an ideal storage solution for large files due to the limited storage capacity and high cost of storing data on the blockchain. Whenever the data size of the Ethereum chain reaches 1 Tb pruned happens, Pruning is the process of erasing older data to save disk space.

However, there are some ways to store files on the Ethereum network. One standard method is to use IPFS (InterPlanetary File System), a decentralized storage system that allows for the efficient and secure distribution of files. IPFS can be used to store files and other large documents off-chain, while the file hash is stored on the Ethereum blockchain, ensuring that the data is tamper-proof and publicly verifiable.

Traditional storage vs blockchain storage

Traditional storage systems rely on a centralized server or data center to store and manage data. This centralized approach makes the data vulnerable to attacks, data breaches, and censorship, as well as more costly to manage and maintain. Centralized systems also require users to trust the centralized authority to manage their data, which can lead to issues with privacy, security, and control. Suppose a company has a data server, which is located in XYZ location if there is a natural disaster, then there is a risk of data loss.

On the other hand, blockchain storage uses a decentralized and distributed network of nodes to store and share data. This makes the data more secure, transparent, auditable, and more efficient and cost-effective to manage. Users have more control over their data, as they can store it themselves or choose who to share it with, without relying on a centralized authority.

Decentralized storage and its benefits

Decentralized storage refers to the use of a network of nodes to store and share data in a distributed and decentralized manner. This approach has several benefits, including:

Increased security: Decentralized storage makes it more difficult for hackers or attackers to access or compromise the data, as there is no single point of failure or vulnerability.
Increased privacy: Decentralized storage allows users to control and manage their data, without having to rely on third-party service providers that may collect or share their data.
Reduced costs: Decentralized storage can be more cost-effective than traditional storage systems, as it eliminates the need for centralized servers or data centers, as well as the associated costs of managing and maintaining them.

Distributed ledger technology

Distributed ledger technology (DLT) is a type of database that is shared across a network of nodes and updated through a consensus mechanism. DLT is a fundamental component of blockchain technology, as it allows for the secure and transparent storage and transfer of data. In blockchain storage, DLT is used to store and manage the data in a decentralized and distributed manner, ensuring its integrity and immutability.

IPFS (InterPlanetary File System)

IPFS (InterPlanetary File System) is a distributed file system that provides a decentralized method of storing and accessing files on the internet. It was created to address some of the limitations of traditional centralized file storage systems, such as slow download speeds, high bandwidth costs, and the risk of data loss or censorship.

Whenever you search for something on the internet like a picture of a cat 🐈, the search engine would provide you with a link, https://website.com/cat.jpg this means there is a computer in the world in which the picture of the cat is stored and we are accessing it using the link. This is called location-based addressing. Suppose the computer is off then the cat image is also not available. There may be some people who have already downloaded the image of the cat but we can't get it from that person.

Content-Base Addressing

IPFS uses Content Base Addressing instead of location, so what does it mean? Instead of locating the file with its address, IPFS located the file with its content. In the article Cryptography, we have seen how each file has a unique hash, IPFS uses this hash method to locate files.

Suppose some people are connected to an IPFS network and one person has a cat image stored in his computer and other people request a cat image in that network. The person who has the image will give it.

Give me the picture with key nsfeH7jn89N

Another person who has requested the cat image will ask for the image with a hash, nsfeH7jn89N, after the person receives the file he or she can compare the hash and verify if somebody has tampered with the data. One of the other advantages is when many people publish the same file in the IPFS, the file is created once as other files have the same hash, which makes the network very efficient.

Storage of data

IPFS stores files as an object, which contains Data and Links, Each object can store up to 256kb of data and each object can store links to other objects. A simple Hello World text is less than 256kb and can store in a single IPFS object. To store data of more than 256kb the data is split into more than one IPFS object and each object store data up to 256kb, after that, the system creates an empty IPFS object which links to the other split objects.

Once the data is added to the IPFS it can't be changed and the data become immutable because it uses a content base address, but how do we change our data if we need to? We can use versioning.

Versioning

IPFS support the versioning of file just like git. Whenever we publish a file in the network, the system makes a commit object of that file. A commit object has two things Parent and Object. The parent stores the previous commit of the file and the Object points to the current version of the file.

IPFS makes sure that your file and its entire history are accessible to other nodes on the network.

What's on the next article?

Next, we will what is Mining and Incentive Models.

Cryptography

Jyotirmoy Barman — Thu, 23 Feb 2023 14:54:02 +0000

Cryptography is a huge topic and constantly evolving as the internet get advances. Here I will explain the topics that will help you understand blockchain better. The word cryptography comes from two words the prefix crypto means “hidden” and the suffix graphy means “writing”. Cryptography is a field of study of secure communication and encryption, With it, we can secure our information and securely communicate with others on the internet as no third person can read it or misuse our data. When we encrypt some data, it can't be read by humans and even computers, to make it possible to use some algorithms like Secure Hash Algorithm (SHA), Message Digest (MD), Windows NTHash, RACE Integrity Primitives Evaluation Message Digest (RIPEMD), Whirlpool, and RSA. The most popular blockchain like Bitcoin and Ethereum use SHA256. But before we know what SHA256 is, we need to understand Hash Function or Hash.

Hash Function

In python3 we have an inbuilt function hash(), which returns the hash integer value of an object, the object can be a string, integer, float, or tuple. Each object pass in the hash function has a unique and fixed-size output but the same object has the same hash value. The hash function generally outputs a fixed-size value, remember that the hash function is a one-way function, in which we can convert an object into a hash value but it is very difficult to convert a hash value to an object. The values returned by a hash function are called hash values, hash codes, digests, or simply hashes.

>>> hash("Hello World!")
8733196720692250248
>>> hash("Hi")
-7322946855749321176

Let us understand with an example, suppose we want to store passwords in the database, we can store passwords in plain text but it will be very risky. So we can use a hash function to store passwords. In the below table, you can see the passwords are stored as a hash value. Whenever users want to access their accounts, the password first converts into a hash value and compares with a hash value that is stored in the database.

User ID	Password
user1	8068189639244901433
user2	-1338079075162857857
user3	-4837162360507738362

This is a simple example of a hash function but there are more Hash functions like MD5 and SHA256, in the blockchain we mostly use SHA256.

SHA256 Hash Function

SHA256 stood for Secure Hash Algorithm 256-bit and was designed by the United States National Security Agency and was first published in 2001. No matter how much the input size is the output will always be 64 characters string which is called a digest.

Input = "Hello World!"
7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069

Python has a built-in library called hashlib() which is designed to provide a common interface to different secure hashing algorithms. The module provides constructor methods for each type of hash. For example, the .sha256() constructor is used to create a SHA256 hash.

import hashlib
password = "hello1234"
hashed_password = hashlib.sha256(password.encode('utf-8')).hexdigest()
print(hashed_password)

hashlib is a module that implements a common interface to many different secure hash and message digest algorithms. Included are the FIPS secure hash algorithms SHA1, SHA224, SHA256, SHA384, and SHA512 (defined in FIPS 180-2) as well as RSA’s MD5 algorithm (defined in Internet RFC 1321).

User ID	Password
user1	b9c950640e1b3740e98acb93e669c65766f6670dd1609ba91ff41052ba48c6f3
user2	d84464181f7f019f3fb10e6bbd06f543d7ac84c4f8e360ebb9402a472ab30ebc
user3	9e4095417158189ad876acbba90c1c61d5767c2e1a507910c4a37cd8a7271d12

Now our passwords are stored in digests, but there is a problem every time we hash an object the same digest is output, Why it is a problem? Suppose there is a database where the most used password is stored with its digest. They can use their database to search the digest and can get the password. To solve this problem we use a nonce.

Password	Digest
password1234	b9c950640e1b3740e98acb93e669c65766f6670dd1609ba91ff41052ba48c6f3
1234password	d84464181f7f019f3fb10e6bbd06f543d7ac84c4f8e360ebb9402a472ab30ebc
ThisIsPassword	9e4095417158189ad876acbba90c1c61d5767c2e1a507910c4a37cd8a7271d12

Nonce

In the previous article Blockchain Structure, there was a section 'Block' in which I have given a short description of Nonce, Nonce is a random number that is used in the proof-of-work mechanism to validate the block and add it to the blockchain. We can implement this idea to generate a different digest of the same password or object.

UUID, Universal Unique Identifier, is a python library that helps in generating random objects of 128 bits as ids. uuid.uuid4().hex we can use this code to generate a random hash. Whenever we call generate_hash(password) function we create a Nonce and a Digest, which we store on our database.

import uuid
import hashlib

password="hello1234"

def generate_hash(password):
    nonce=uuid.uuid4().hex # This nonce need to store in database
    hash= hashlib.sha256((password.encode('utf-8'))+nonce.encode('utf-8')).hexdigest()
    return hash

print (generate_hash(password))

User Name	Nonce	Password
user1	30eac1d2bdfe42de8cd8fc34c105f95c	31bb06a1c78d0709e126686d7f5dc086d68c6b6aa10587305a4273228ada131b
user2	12c0ba5f3bb943fd81f2e9de76b0f907	01f8326285644388aa414922145aaeaf1bd9104f28193bbd32103799f6827a01
user3	e3155754796b4cb0824e7fdbffcc471c	838d518e1ffb4844ac6d8d751588cf0e43b2bde0bd015c051e026dc9e0668b1e

To check if the password is correct, we take the password from the user and the nonce and the stored digest from the database, recreate the digest and check if the recreated digest is the same as the stored digest.

import uuid
import hashlib

# let us get password from the user
password="hello1234"

# let us get saved nonce and digest from the database
nonce="e3e39410b9d3481ba3c315a77b533c59"
hash_password="959595f7145ab845a0dceb476d980c4118467ef637a7178502400ba6ce5929ff"

def check(password,nonce):
    # recreate the digest
    user_hash= hashlib.sha256((password.encode('utf-8'))+nonce.encode('utf-8')).hexdigest()
    # checking the user hash with the stored hash
    if (user_hash==hash_password):
        return True
    else:
        return False

print(check(password,nonce))

What is Encryption

Encryption is the process of changing plain text which is human-readable to a ciphertext that humans can't read. This is a two-way process which means when we encrypt data, we can change or decrypt it to its original form. To decrypt data we need a key, key is a random string of bits generated specifically to scramble and unscramble data.

Symmetric Key Encryption

With symmetric-key encryption, the same key is used to encrypt and decrypt the data. The simplest and least secure method of encryption is this one. A secure method of key transfer is required since the recipient needs the key to decrypt the message. The middle data can be read by anyone possessing the key.

Python has a library cryptography which will help us to encrypt our data. cryptography includes both high-level recipes and low-level interfaces to common cryptographic algorithms such as symmetric ciphers, message digests, and key derivation functions. Install cryptography with:

pip install cryptography

To perform encryption and decryption of a message using the Fernet symmetric encryption algorithm. Here's the step-by-step process:

Import the Fernet class from the cryptography.fernet module.
Define a message string, which is "I need coffee" in this case.
Generate a random encryption key using the generate_key() method of the Fernet class.
Print the key to the console. This key will be used to both encrypt and decrypt the message.
Create an Fernet object using the key generated in step 3.
Use the encrypt() method of the Fernet object to encrypt the message. The encode() method is used to convert the message string to bytes, which is required for encryption.
Print the original message and the encrypted message to the console.
Use the decrypt() method of the Fernet objects to decrypt the encrypted message. The decode() method is used to convert the decrypted bytes to a string.
Print the decrypted message to the console.

from cryptography.fernet import Fernet

message = "I need coffee"

key = Fernet.generate_key()
print(key)

fernet = Fernet(key)

encMessage = fernet.encrypt(message.encode())

print("original string: ", message)
print("encrypted string: ", encMessage)

decMessage = fernet.decrypt(encMessage).decode()

print("decrypted string: ", decMessage)

Note that because the encryption key is randomly generated each time the code is run, the encrypted message will be different each time.

Output

original string: I need coffee
encrypted string:  b'gAAAAABj9OSJfh9U2eiGTnogdjOVbCKhhceTXYkwYlDLkR_V2JouTw1hBDTgRPpKa3hGkxR4Im3GS1r0YSDhqetouD94i69lLA=='
decrypted string:  I need coffee

Public Key Cryptography

Public key cryptography, also known as asymmetric cryptography, is a cryptographic system that uses two mathematically related keys – a public key and a private key – to encrypt and decrypt messages. The keys are generated in such a way that the public key can be widely distributed and shared with anyone, while the private key is kept secret and only known to the owner.

The public key is used to encrypt messages, which can then only be decrypted with the corresponding private key. This means that anyone can encrypt a message using the recipient's public key, but only the recipient with the corresponding private key can decrypt the message. In this way, public key cryptography enables secure communication between two parties who have never met or shared a secret key before.

Secure Communication

To understand public key cryptography we need to see how we can use this concept to message someone securely in a network. Let us consider we have 4 people in the network Green, Blue, Purple, and Red. Here Green wants to send a message to Blue, so what he should do?

Every person in the network needs to generate their own Public Key 🗝️ and a Private key 🔑. The Private Key needs to keep secret 🤫.
Now, every person in the network can broadcast their public key in the network.
Green can take Bule’s public key 🗝️ from the network and encrypt the message with it, which will give us a cipher text.
Now, Green can broadcast this cipher text to the network, where every person in the network can access this encrypted text.
But since the corresponding private key 🔑 is only known to Blue, only Blue can decrypt it. Any other person in the network can't decrypt it.

When Blue receives a message, which when he decrypts says “I Need Coffee”. How can Blue know that Green and not others sent the message?

Digital Signatures

Blue gets the cipher text and he decrepit it with his private key but Blue does not know who sends this message in the network. He knows it was sent for him as he was able to decrepit the message.

A digital signature is a mathematical scheme for verifying the authenticity of digital messages or documents. A valid digital signature, where the prerequisites are satisfied, gives a recipient very high confidence that the message was created by a known sender (authenticity), and that the message was not altered in transit (integrity).

This can be achieved if the message is “signed” by its sender (Green). The receiver of the message can then verify the signatures.

The first method we can use is to encrypt the message with Green's Private Key 🔑 so that when Blue receives the cipher text, he can decrypt it with Green's Public Key🗝️. With this, he surely knows that Green send this message to the network.

But there is a problem when Green broadcast this message to the network everybody can decrypt this message as Green's public key is already available in the network.

Instead of signing the entire lengthy message the sender computes a hash (digest) of the message and signs that with his public key instead. The receiver can then re-compute the message hash and compare it with the signed hash to ensure that message was not tampered with.

Adding a Digital Signature

Green computes a message digest by hashing the message she is about to send. SHA256(“I Need Coffee”).
Green calculates the message digest = HASH(message);
Green signs the message digest by encrypting it with her private key.
Green appends the signed digest with a message and encrypts it with Blue's public key Green sends it over to Blue.

Verifying a Digital Signature

Blue decrypts the message using his private key
Blue decrypts the digest using Green's public key
Blue computes the digest of the message. If it matches the digest he received as signatures it confirms that:
- The message is not tampered with
- The message has been sent by Green only - Since only Green's public key could decrypt the hash

But wait! how could Blue know the public key🗝️ which he is using truly belong to Green? it could be Red pretending to be Green.

Certificate Authority

In a network, there can be people who can pretend to be someone or we can say, fake people. To deal with this type of problem, we set up a Certificate Authority. Think of it as an Authority that is responsible for verifying our public key in the network.

How does a Certificate Authority work?

Green must contact the CA to get a certificate(digitally signed public key) to prove her public key to others. All other participants on the network will be able to trust the public key is Green's if they trust the CA.
The CA would take Green through an approval/onboarding/manual verification process and issue a certificate. The certificate itself is a list of certified attributes of the entity it issued to Green. It has attributes like the public key, the name of the holder, etc. All this data is digitally signed by the CA using its private key.
Green then shares this certificate as proof of his public key with Blue.
Since Blue has the CA in his trusted CA list(CA’s public key), he can verify and trust the certificate shared by Green and hence trust her public key.

What's on the next article?

Next, we will see how blockchain storage work.

Decentralization with Blockchain

Jyotirmoy Barman — Sat, 18 Feb 2023 07:51:16 +0000

To understand decentralization first we need to understand our current internet or web2, in our current internet model, a few companies are controlling the internet like Amazon, Google, Microsoft, etc.

The Internet is an interconnected network of computers around the world.

How does the internet works?

You are reading this article on your device, but did you know how you get it? you probably think you just type the article name on Google or type the URL of this page on your web browser and the page appears but there is more to know.

If we want to communicate between computer we need to link them, we can be connected them by wire but when there are many computers then the wiring becomes complex, Suppose we want to communicate between 10 computer each computer need to connect to the other 9 computers with wire and we need to do the same with rest other 9 computers, so we need total 45 wire just to connect 10 computer directly to each other.

To make this simplify we can use a router, routers are the devices that manage and make sure the message route to the correct device. We can connect the router with only a few computers but as the router is also a computer it can connect to another router to form a network. Suppose a router can connect to 10 devices and there are 3 routers each connecting to 5 computers. Still, if we want to send a message from router 1 computer to router 2 computers we need to connect this router so we can use another router to secure it.

The network we just created is contained to our self like in a building or a local area but if we want to connect to other networks around the world we need a well-structured infrastructure that is connected to other networks, so here comes the play of ISP( internet service provider ) like JIO, Airtel, and BSNL they are the internet provider or like a router which connected around the world. This forms a network of computers which we called the Internet.

Now the question here is, How this article is displayed on your device, and where from this data come from? Every computer has a unique IP address, the IP address is a unique string of characters that identifies each computer using the Internet Protocol to communicate over a network. Whenever we upload some data to the internet like Photos, Videos, or Articles this is stored in a Data-Center, Data-Centres are massive computers with lots of data storage that store the data. This article is stored in a Data-Center, suppose we can say this article is stored in a Data-Center which is located in Mumbai, and that Data-Center is connected to an internet service provider, So when we call the server with this article's URL on our browser, the browser will look into DNS and return the IP address. After we obtain the address we form a connection and access this article.

The Domain Name System (DNS) is the phonebook of the Internet where every URL is mapped to the IP address of the server.

How the internet is centralized?

The internet can be decentralized but there is some aspect of the internet that is centralized and can be problematic. Here are some of the centralized points:

Control of infrastructure: As we have seen the internet is made of many computers around the world and that can be decentralized but to make this structure we need ISPs and hosting providers, and this means the company which provides it has the power to control the internet. Here is an example, if the government wants to block some websites in their country, they order the ISPs to block the URL of the website.
The dominance of a few large companies: There are some segments of the internet which is control over by a few big companies, such as Google holds a 92.9% share of the search engine segment, and Meta holds 76.55% of the social media segment. This affects the free flow of information, privacy, and competition.
Use of centralized platforms and services: when we want to surf the internet we need an email address like Gmail or when we need to message someone we need to use a messaging app like WhatsApp and if we want to store data in the cloud we need a cloud storage company like Google cloud or iCloud, this service is often centralized and we need to depend on this companies to handle our data correctly and if there is any data leak or misuse of our data it can affect or privacy.

What is Decentralization?

Decentralization refers to the concept of distributing the power from a single decision-making authority to individuals or entities. Instead of relying on a single group of people to make all the decisions the power is distributed among many parties. The concept of decentralization can be implemented in many places like ownership, finance, land record, politics, and many more.

Blockchain helps us to implement this concept in the real world. Decentralization is the key characteristic of blockchain technology. All participants have equal access to the network and can participate in the decision-making process.

In a blockchain network, transactions are verified and added to the blockchain through a process known as consensus. Consensus is achieved through a decentralized network of nodes that work together to validate transactions and maintain the integrity of the blockchain. Each node has a copy of the blockchain and uses algorithms to verify transactions and reach consensus with other nodes.

Why it matters?

In our current internet, some companies are responsible for the critical functioning of the internet but as these companies are centralized systems, if the centralized authority is compromised, the entire system may be at risk. Decentralization can provide greater security by reducing the risk of a single point of failure. As blockchain has distributed control among multiple nodes, it is difficult to compromise the entire system.

One of the other points is that there is minimal to no transparency in the centralized system, the decision-making and transaction are decided only by a few people and it is difficult for an outsider to know what happens in a company. But, in a blockchain, everyone can contribute to and verify every transaction, this established a great transparent and open system that helps build trust.

As I have explained before that in blockchain the control is distributed among multiple nodes, which means anyone can run a node and have equal control as others, and everyone has equal access to services and opportunities on the blockchain. This provides greater access by removing intermediaries and enabling peer-to-peer transactions.

Applications and uses

There can be many applications of blockchain but some of the famous uses of blockchain are :

Decentralized finance (DeFi) 💸: The money you own is controlled by the government and centralized authorities, who can block payments or deny you access to your money. There is also the risk of error and corruption due to human intervention in our current financial system. As an alternative, we can use Decentralized finance (DeFi), a collective term for financial products and services that are accessible to anyone which is based on blockchain. Here every transaction is open and accessible to anyone with an internet connection.
Non-fungible tokens (NFT) 🖼️: NFT provides proof of ownership of digital assets on the internet. Suppose you create a digital asset like a collectable, music, or video, How do you prove it is yours? Whenever you minted a digital asset on a blockchain it creates a unique token of that NFT and stores it in your wallet, it now lives on the blockchain and anybody can verify that it is yours. As you have minted it first. NFTs can also use to prove the ownership of real-world objects or assets.
Decentralized autonomous organizations (DAOs) 🤝: DAOs are the digit organization that lives on the blockchain, in this organization there is no central authority, and rules are written on smart contracts. The voting system of a DAO is typically based on the amount of cryptocurrency that a member has invested in the organization, known as tokens or shares.

There are more applications and uses of blockchain which I will explain in detail later in this series.

What's on the next article?

Next, we will see what is cryptography as it is important to know before we start learning blockchain.

Blockchain Structure

Jyotirmoy Barman — Sun, 12 Feb 2023 10:02:35 +0000

Today we are going to see how a blockchain work. In our previous article, we have seen some of the terminologies related to it, if you have not read it you should go through it "What is Blockchain?".

This article will be divided into 6 parts :

SHA256 Hash
Block
Blockchain
Distributed Blockchain
Tokens or Transaction

SHA256 Hash

First, let us see what is SHA256 HASH I will explain it in detail later on. Here is a short description, SHA256 Hash is a function that takes an input and returns a fixed 256-character of string which is called Hash, and each Hash is unique for different data.

Here you can see both the hash are different as the first letter 'H' is capitalized in the first input and the 'h' small letter in the second although the other characters are the same.

Later in this series, there will be an article on Cryptography here I will explain this topic thoroughly.

Block

Now we will see what is a block, In simple in a block we have a block number, nonce, data, and hash. Here you can see the new word Nonce, now you are thinking what is a nonce? Nonce is a random number that is used in the proof-of-work mechanism to validate the block and add it to the blockchain.

To generate a signed hash that can be added to a blockchain, the input data, such as "Hello World!", must first be hashed using a cryptographic hash function. The resulting unsigned hash, such as "7f83b......d9069", is not suitable for this purpose as it does not meet the specific criteria required for a block hash in a blockchain.

To produce a signed hash, a miner employs a brute-force approach to find a nonce value that, when combined with the block number and data, generates a hash that meets the necessary criteria. This often involves starting with a nonce of 1 and incrementing it until a value is found that produces a hash that begins with the desired number of zeros (e.g. "0000"). The combination of the block number, nonce, and data results in the final block hash, which can then be added to the blockchain.

Blockchain

Till now we have seen what is a block and what is a SHA256 Hash now we will see what is blockchain but before that, have you seen one more section above the Hash in the below table?

Blockchain is a series of blocks that contain data and which is connected to the previous block with a cryptographic hash. In a block, we have a previous hash data field that stores the hash of the previous block.

Previous Hash stores the hash of the previous block so we can verify the previous block, It forms a chain-like structure as each block is connected to the previous block. In the first article, I talk about the Genius block under the Ledger section, here you can see the first block (which is block number 1) has Prev equal to "0000....000" as the first block does not have a block before it, so the previous hash will be NULL or "000....000".

Whenever a new block is added to a blockchain it takes the hash of the previous block and stores it, Check block 1 Hash and block 2 Prev, the hash you will find is the same.

Whenever we try to temper the data of the previous block the blocks will be not valid. So, we need to mine the blocks one by one.

Distributed Blockchain

Now further extending the knowledge of blockchain, we will see what is Distributed blockchain. It is a system, where a ledger is replicated and distributed to each node around the world.

Blockchain nodes are the moderators that build the infrastructure of a decentralized network.

A decentralized ledger that is maintained by a network of computers is known as a distributed blockchain. There is no centralized authority or single point of control in a distributed blockchain. Instead, each node in the network keeps a copy of the ledger and uses consensus techniques to verify transactions. As it becomes more challenging for any one node or set of nodes to influence the ledger, this design enables enhanced security, transparency, and reliability.

Tokens or Transaction

Whenever we add a block there is some data but before the data doesn't mean anything or it was useless, to make the blockchain valuable or worth something we can store transactions.

Coinbase Transactions

In the blockchain, whenever a new block is mined by the miner he is rewarded with a coin in his account, this coinbase transaction doesn't have a previous reference.

Let us think the Genius block is mined by Anders so he is rewarded with 100 coins in his account now he can give these coins to other accounts in the blockchain, these coins do not have a previous reference but when Sophia tries to send coins to another account she needs to have coins in her account she can get this coin from Anders or when the blockchain was created the creates can distribute this coin.

What's on the next article?

Next, we will see what is decentralization and compare it with our current internet.

What is Blockchain?

Jyotirmoy Barman — Fri, 10 Feb 2023 19:23:18 +0000

According to Wikipedia “A blockchain is a distributed ledger with growing lists of records (blocks) that are securely linked together via cryptographic hashes.” In other words, it is a list of transactions and each bundle of transactions are linked to the previous block.

Blockchain is DLT (Distributed Ledger Technology) which is immutable and distributed in nature, it stores and replicated the data in each node. To understand the Blockchain we should first understand some words.

Immutability
Distribution
Ledger
Node

Terminology

Let us see this word and what it means.

Immutability

Immutability means once you have written on a blockchain it can't be deleted how much you try. It is impossible to erase data from a blockchain. So, it is considered the safest data storage. In a web2 database system, we have access to the data, we can create, modify or delete the data but in blockchain, we can only add and modify data. In web2, we need to trust the authorities and hope they don't delete or modify our data without our permission, but in blockchain, we don't need to trust others to handle our data, as no third person is involved.

Distribution

In Blockchain the data Is replicated and distributed to every node or host or peer, we can trust the data if most of the node is working correctly or in a valid state if a node is misbehaving the node goes to an invalid state and the node is kicked out from the network. Each node has the whole ledger or blockchain in its local storage this guarantees high availability and security as the data is easily verifiable and accessible.

Ledger

Ledger is a list of transactions recorded with a time stamp and stored in a block and each block is connected to the previous block, the first block or the head block does not have a previous block so its previous block is NULL. The first block is called Genesis Block, You can check the first block of any blockchain in etherscan.io

Node ( Host or Peer)

Node is the host, server, or computer in which the blockchain program runs. Think of it as a virtual machine that runs on another OS but it allocates its own resource. Each node has a copy of the blockchain in the host. Anyone can run a node if he or she has the required configuration device. By running a node anyone can earn blockchain cryptocurrencies which can be used as money in that ecosystem.

What's on the next article?

In the next article, we will see the blockchain structure and how it works, so make sure to subscribe to the newsletter and follow me on Twitter.

9. Palindrome Number

Jyotirmoy Barman — Fri, 10 Feb 2023 19:15:39 +0000

Question

Read the Question here Click Here

Input: x = 121
Output: true
Explanation: 121 reads as 121 from left to right and from right to left.

Answer

class Solution {
public:
    bool isPalindrome(int x) {
        int oldNum=x;
        int newNum=0;
        while(0<x){
            int temp=x%10;
            newNum=newNum*10+temp;
            x=x/10;
        }
        if (oldNum==newNum){
            return true;
        }
        else{
            return false;
        } 
    }
};

Here we will reverse the number and check that the given number is equal to the new number. First, we need to store the old number in a variable as the variable x will be 0 at last, so we are using oldNum it as a variable to remember our given number. The variable newNum is where our reverse number will be stored.

Now we will use a while loop and check if the x is greater than 0 and run it till the x become 0. The variable temp store the last number of the x, eg., given the number 121 then 121%10=1, 1 is stored in the temp . After we get the temp then we move to the next line, here we are multiplying the newNum with 10 and adding the last number which we stored in temp eg., newNum = 0*10+1 -> newNum = 1 and then we will remove the last number from the x by dividing x by 10. This loop continues till the x become 0.

Till this point new will get our reverse number which is stored in, now we just need to compare this with the oldNum, if the number is the same then return true or else false.

Input : 121

x = 121
oldNum = 121
newNum = 0
Check if x is greater than 0 (0<121) ✅
    temp = x % 10 = 1 
    newNum = (newNum * 10) + temp = (0*10) + 1 = 0 + 1 = 1
    x = x / 10 = 121 / 10 = 12

x = 12
oldNum = 121
newNum = 1
Check if x is greater than 0 (0<12) ✅
    temp = x % 10 = 12 % 10 = 2
    newNum = (newNum * 10) + temp = (1*10) + 2 = 10 + 2 = 12
     x = x / 10 = 12 / 10 = 1

x = 1
oldNum = 121
newNum = 12
Check if x is greater than 0 (0<1) ✅
    temp = x % 10 = 1 % 10 = 1
    newNum = (newNum * 10) + temp = (12*10) + 1 = 120 + 1 = 121
    x = x / 10 = 1 / 10 = 0

x = 0
oldNum = 121
newNum = 121
Check if x is greater than 0 (0<0) ❌

check if oldNum is equal to newNum (121 == 121) ✅
    return true

26. Remove Duplicates from Sorted Array

Jyotirmoy Barman — Fri, 10 Feb 2023 19:04:43 +0000

Question

Read the Question here https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/

Answer

Input: nums = [1,1,2]
Output: 2, nums = [1,2,_]

Input: nums = [0,0,1,1,1,2,2,3,3,4]
Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int i = 0;
        for (int j = 1; j < nums.size(); j++) {
            if (nums[i] != nums[j]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
};

This algorithm will work only on sorted array .

The function take a vector of integer (as a reference) and return an integer length of modifies vector after removing the duplicate integer. The function start with a if condition which check if the vector is empty and if it is true it will return 0 , if it is false and there is elements in vector it will continue. The algorithm uses two pointer i and j which itreate over the vector and and check for duplicate integers. The pointer i starts with the first element and the for loop where j starts with second element. Inside the for loop, if statement check if index i element is not equal to index j element, and if this is the case, this mean the index j element is not duplicate of index i element , so the element j is assigned to i+1. Then the pointer i is increment with 1. This process continue till the end of the vector.

At the end of the function, the pointer i+1 is returned as the length of the modified vector after removing duplicates.

Its time complextity is O(n) as we are using only 1 for loop so the time complexity in depend on the size of the vector.

This is how I debug, you can go through it to see what is happening in the code.

vector -> 0 0 1 1 1 2 2 3 3 4
i=0    -> ↑
j=1    ->   ↑
if (0!=0) ❌ 
----------------------------------------
Vector -> 0 0 1 1 1 2 2 3 3 4
i=0    -> ↑
j=2    ->     ↑
if (0!=1) ✅
    Vector -> 0 0 1 1 1 2 2 3 3 4
    i=1    ->   ↑
    nums[i] = nums[j]
    nums[1] = nums[2]
        0   =    1
    Vector modified (0 is replaced with 1)
                ↓
    Vector -> 0 1 1 1 1 2 2 3 3 4
----------------------------------------
Vector -> 0 1 1 1 1 2 2 3 3 4
i=1    ->   ↑
j=3    ->       ↑
if (1!=1)❌
----------------------------------------
Vector -> 0 1 1 1 1 2 2 3 3 4
i=1    ->   ↑
j=4    ->         ↑
if (1!=1) ❌
----------------------------------------
Vector -> 0 1 1 1 1 2 2 3 3 4
i=1    ->   ↑
j=5    ->           ↑
if (1!=2)✅
    Vector -> 0 1 1 1 1 2 2 3 3 4 
    i=2    ->     ↑
    nums[i] = nums[j]
    nums[2] = nums[5]
        1   =    2
    Vector modified (1 is replaced with 2)
                  ↓
    Vector -> 0 1 2 1 1 2 2 3 3 4
----------------------------------------
Vector -> 0 1 2 1 1 2 2 3 3 4
i=2    ->     ↑
j=6    ->             ↑
if (2!=2) ❌
----------------------------------------
Vector -> 0 1 2 1 1 2 2 3 3 4
i=2    ->     ↑
j=7    ->               ↑
if (2!=3)✅
    Vector -> 0 1 2 1 1 2 2 3 3 4 
    i=3    ->       ↑
    nums[i] = nums[j]
    nums[3] = nums[7]
        1   =    3
    Vector modified (1 is replaced with 3)
                    ↓
    Vector -> 0 1 2 3 1 2 2 3 3 4
----------------------------------------
Vector -> 0 1 2 3 1 2 2 3 3 4
i=3    ->       ↑
j=8    ->                 ↑
if (3!=3) ❌
----------------------------------------
Vector -> 0 1 2 3 1 2 2 3 3 4
i=3    ->       ↑
j=9    ->                   ↑
if (3!=4)✅
    Vector -> 0 1 2 3 1 2 2 3 3 4 
    i=4    ->         ↑
    nums[i] = nums[j]
    nums[4] = nums[9]
        1   =    4
    Vector modified (1 is replaced with 4)
                      ↓
    Vector -> 0 1 2 3 4 2 2 3 3 4
----------------------------------------
For Loop Stop
----------------------------------------

Answer
Vector -> 0 1 2 3 4 2 2 3 3 4
return i+1 = 5

1. Two Sum

Jyotirmoy Barman — Fri, 03 Feb 2023 06:24:05 +0000

Question

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

Answer

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
      vector<int> ans;
      for (int i=0;i<nums.size();i++){
        for (int j=i+1;j<nums.size();j++){
            if ((nums[i]+nums[j])==target){
                ans.push_back(i);
                ans.push_back(j);
            }
        }
    } 
    return ans; 
    }
};

The solution we will be using is brute force, the function takes two variables one is nums which contain the vector and the other one is a target which we need to find by summing two indexes in the vector and if we got the sum we will return the index in a new vector.

Before we start the for loops first we need to make an empty vector, which we will call ans. we will use a nested for loop to check if the target is present in the array. The first loop starts with the i'th which is 0 and stops at (vector size - 1) and the inner for loop starts at i+1 and stops as same as (vector size -1), if the index i and i+n (where n is a number less than vector size but greater than i) is equal to the target value we will push the index to the new array ans and return it. It has O(n^2) time complexity as it has two nested loops. Below you can see an animation of how this program works.

Set up Tailwind in your Project

Jyotirmoy Barman — Thu, 02 Feb 2023 05:28:39 +0000

Tailwind CSS is a utility class framework that helps you make a responsive web design. In this article, I will teach you, how to set up a tailwind in the project.

Play CDN ( Method 1)

This is the easiest way to use Tailwind, but it is not recommended for a production application. <script src="https://cdn.tailwindcss.com"></script> inside the <head> tag.

An Internet connection is required!

<!doctype html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="https://cdn.tailwindcss.com"></script>
</head>
<body>
  <h1 class="text-3xl font-bold underline">
    Hello world!
  </h1>
</body>
</html>

Tailwind CLI ( Method 2 )

Tailwind CLI is a tool to quickly set up your project a generate required styling automatically. First You need to install node.js on your computer. After you have installed Node.js creates a folder (Tailwind-Project) and run the below command on your terminal.

Internet connection is not required after you have done the setup once!

mkdir Tailwind-Project
cd Tailwind-Project

npm install -D tailwindcss
npx tailwindcss init

After you have run the above command you will see a tailwind.config.js file in your folder.

➜  Tailwind-Project tree
.
└── tailwind.config.js

0 directories, 1 file

Create a src folder inside Tailwind-Project and add your HTML, CSS, and Javascript files inside it.

bash
➜  Tailwind-Project tree
.
├── src
│   ├── input.css
│   ├── main.html
│   └── main.js
└── tailwind.config.js

1 directory, 4 files

Now it is time for configuring tailwind.config.js you will something just like this in the code.

javascript
module.exports = {
  content: [],
  theme: {
    extend: {},
  },
  plugins: [],
}

Replace or Rewrite the code with this ↓. Here are adding the paths to all of your template files in your tailwind.config.js file.

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ["./src/**/*.{html,js}"],
  theme: {
    extend: {},
  },
  plugins: [],
}

Open the input.css file and paste the below lines.

@tailwind base;
@tailwind components;
@tailwind utilities;

Now run this command to start the Tailwind CLI build process, it will generate a file under a /dist/output.css , and here is the file which will contain all your CSS styling.

npx tailwindcss -i ./src/input.css -o ./dist/output.css --watch

Now you will see something just like this.

warn - The `content` option in your Tailwind CSS configuration is missing or empty.
warn - Configure your content sources or your generated CSS will be missing styles.
warn - https://tailwindcss.com/docs/content-configuration
Browserslist: caniuse-lite is outdated. Please run:
  npx browserslist@latest --update-db
  Why you should do it regularly: https://github.com/browserslist/browserslist#browsers-data-updating

Rebuilding...
Done in 88ms.

Now the project structure should see like this. Here you will see a new file under the folder dist the file name will be output.css. This is a file that we need to insert into our HTML.

➜  Tailwind-Project tree
.
├── dist
│   └── output.css
├── src
│   ├── input.css
│   ├── main.html
│   └── main.js
└── tailwind.config.js

2 directories, 5 files

Paste the below command into your HTML file (main.html). The line <link href="/dist/output.css" rel="stylesheet"> is the line that links output.css to main.html . Now you can write class can the Tailwind CLI will automatically build the CSS file.

xml
<!doctype html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link href="/dist/output.css" rel="stylesheet">
</head>
<body>
  <h1 class="text-3xl font-bold underline">
    Hello world!
  </h1>
</body>
</html>

To learn how to use Tailwind CSS head over to tailwindcss.com.

Follow me on Twitter Jyotirmoy Barman.

NAPPTIVE made Cloud-Native Easy 🤯

Jyotirmoy Barman — Thu, 02 Feb 2023 05:17:40 +0000

Introduction

First, let me talk about why we need to run the application on the cloud, let's take an example of a static website, which contains index.html we can run this file on our computer or we can say local host, but this website only can be accessed by you, and other people on the internet cannot access it. You can run a server on your computer which will expose your local host to the internet but you need to run your computer 24X7 so other people access your website, which is not practical for most of us, but what we can do? we can use a cloud provider or you can say a person who is giving their computer to run the program 24X7. Now people can access your index.html file at any time and from any computer.

Now we understood why we need a cloud, but one more problem arises the pain of configuring and handling the traffic and learning docker, Kubernetes, etc., But if you are a developer who just wants to focus on your work, like improving the application. So, we can use Napptive to help us with all these 👍.

Did You ask What is Napptive?🤔 I am here to explain.

NAPPTIVE is a cloud-native application platform. It is a platform that provides an integrated solution that can be used by developers and non-technical users. Enough of the description, let us try this platform.

Deploy Static Website

To deploy a static website first, we need to upload the code to GitHub, for now, we will use the repository github.com/napptive/static-example-launcher-app or you can use yours. Make sure to login into your Napptive account, you can use an Email, Google, or GitHub account, and after that choose a username [user name should be in lowercase and without space] for your login. Now login to your account with your chosen login method. After you have logged in you can see something just like this :

You can see a tutorial pop up, you can read it. As you can see, this is the dashboard where you can maintain your apps. NAPPTIVE provides a catalog where can you simply set up your project, and click on the top left corner second option Catalog.

Click the deploy-static-app after that click on ► Deploy :

After you have clicked it, you can see a YAML code inside the Components configuration, here we need to configure the code if you want to deploy your own code but as I have said I will deploy the default code.

components:
    - name: deploy-static-comp
      type: webservice
      properties:
        image: napptive/playground-launcher-static-nginx:1.22-v1.0.0
        cpu: "100m"
        memory: 128Mi
        ports:
            - port: 80
              expose: true
#-------------------------------------------------------------------
        env:
            - name: LAUNCHER_TARGET_REPO # target_repo
              value: https://github.com/napptive/static-example-launcher-app.git
#-------------------------------------------------------------------
            - name: LAUNCHER_REPOSITORY_USER
              value: ""

            - name: LAUNCHER_REPOSITORY_ACCESS_TOKEN
              value: ""
      traits: # Trait section
        - type: napptive-ingress
          properties:
            port: 80
            path: /

Here you can see the lien I have hilited, you need to change the value: link with your GitHub repo link, and you can give any name: to your app. After you have done you can see the ► Deploy button in the bottom right corner, click it. Conformation is asked just click ► Yes. deploy. After you have clicked you can see a new app in your dashboard.

First, the CPU was using 0% but now you can see we are using 10% of the CPU and 3% of ram, remember different projects can use a different amount of resources. Free users have 1 CPU, 4000 MB RAM, and 1000 MB RAM. If you need more ram you can upgrade to the PRO plan.

Now, Check the deployment, you can access the deployment with the link which is in the section endpoints for me the link is deploy-static-comp-80-cfdakufl20br8thb27s0.apps.playground.napptive.dev, you can also go to this link and check this website.

To study more read the doc :

https://docs.napptive.com/tutorials/Deploying_Drawio.html

Just Like this, you can deploy Python Apps, NodeJs Apps, WordPress, and many more.

Remove Even Integers From an Array

Jyotirmoy Barman — Mon, 02 Jan 2023 21:18:24 +0000

Implement a function RemoveEven( int *& arr, int n ) which takes an array arr and its size and removes all the even elements from a given array.

Input

5
1 2 3 4 5

Output

1 3 5

Solution

#include<iostream>
using namespace std;
int NewArraySize=0;
int * RemoveEven(int *& arr, int n){
    int * NewArray=new int[]{};
    for (int i=0;i<n;i++){
        if ((arr[i]%2)==1){
            NewArray[NewArraySize++]=arr[i];
        }
    }
    delete [] arr;
    arr=NewArray;
    return arr;
}

int main(){
        // Array size
    int n=0;
        cin>>n;

        // Array
    int * arr=new int[n]{};
        for (int i=0;i<n;i++){
                cin>>arr[i];
        }

        // Calling the funciton
    arr = RemoveEven(arr,n);

        // Printing the new array
    for (int i=0;i<NewArraySize;i++){
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    return 0;
}

Here inside the function RemoveEven()we created a new dynamic array NewArraywhich will be used to store the odd element. Next, we are using a for loop to check if an element in an array of index i is odd or even if the reminder is 1 then it is an odd number, it will be pushed in the NewArray and then the variable NewArraySize will be + 1 so we can keep track of the size of the array as we can’t get the dynamic array size with sizeof() function. After, we have successfully added all the odd number elements in the NewArray we will delete all the elements of the arr as we want to copy the NewArray elements in arr and then return it.

Run the code with g++ -std=c++20 fileName.cpp -o a.out and ./a.out

Compile and Run C++ file with single custom command

Jyotirmoy Barman — Wed, 02 Nov 2022 21:54:41 +0000

I this article I am going to show how you can write your own custom command in terminal. For the purpose of explanation I am going to show how you can build any run a C++ File with just a single command .

First check if you have intsall the g++ compiler in your computer or not, to check it run this command, it will show the version of your g++ compiler. If it shows you ther version you are ready to go.

g++ --version

Open your Terminal App in Mac, and type cd this will bring you ~ or /Users/YourUserName folder.

In this folder you need to make a new file in which you want to write the command . For this example I am giving the file name .custom_command.sh, now let us understand the file name as you can see I have given a . in-front of the file name, dot will hide the file and save from accidental delete. In place of custom_command you can give any file name and the file ends with the extension .sh which is shell script.

This command will make the file.

touch .custom_command.sh

Now, We need to write the Script inside this file, open the file with vim.

vim .custom_command.sh

Now press I on vim and copy the code below and paste it in the file. After you have pasted the code hit esc and write :wq and hit enter this will save the file changes.

#!/bin/bash

function run(){
        if g++ -std=c++20 $1 -o runed; then
        ./runed
        else
                echo 'Error in '$1
        fi
}

Code Explanation

First Line #!/bin/bash says that with which we need interact, I our case we are interacting with the bash.

Second we have made a function with the name of run this is the command with which we will compile and run the c++ file at the same time. For an example we have a C++ file name print_helloworld.cpp which output HelloWorld!, first we need to compile it and then run it but with the custom command we can do the both with just one command.

run print_helloworld.cpp

You can give your own function name, replace the run with your own desired word in the .custom_command.sh file, for an example if your replace the run with runcpp than you need to type the below code to run the C++ file.

runcpp print_helloworld.cpp

Now Coming on the third line, as you can see the code if inside if loop ( the loop basically says if the file compile then run the compiled code or else print a error message ). We need to see the line which says g++ -std=c++20 $1 -o runed this mean that we are using a g++ compiler to compile our c++ code and we are using c++ version 20 '-std=c++20' after which we are taking an input $1 which is the file name and creating a new file -o runed in which we will have our complied code.

If the file compiled successfully then it will run the code with the line ./runned.

Back to Setup

After you have successfully made the file .custom_command.sh open ~/.bashrc with vim if you use Bash or ~/.zshrc if you use ZSH and paste the below command at the last, this will allow to run your command from any session or terminal window.

source ~/.custom_command.sh

Notice : If you have changed the file name in which you have written the custom command then replace the .custom_command.sh with your file name.

Now hit esc and then type :wq and then hit enter. The file has been saved. Now restart you terminal.

Test The Command

run print_helloworld.cpp

If you like the article then hit the like button and follow me on twitter for my latest update @jyotirmoydotdev.