Introduction to Solana Part 1

Solana is a highly scalable and secure open source blockchain that incorporates a new method of timekeeping originally proposed by its founder Anatoly Yakovenko. Solana solves the time issue that other decentralized networks such as Bitcoin and Ethereum depend on by fixing the trust issue between nodes that arises from synchronization in distributed systems.

Now imagine if a node wanted to receive some message along with a timestamp. Simply obtaining this timestamp isn’t secure at all. One solution to this is having the message be reviewed by multiple nodes that would then verify this timestamp. After a threshold for the number of nodes required to verify it through signatures has been reached, the node receiving the message can now trust the timestamp.

In Solana, nodes don’t need to wait for the verification of additional nodes because it uses a verifiable delay function, a cryptographic algorithm. This VDF, verifiable delay function, is evaluated through sequential steps. This method utilizes a specific parameter of nLockTime known as block height instead of timestamp. This nlocktime is a parameter that asks for a specific time so that it is accepted. In order to secure the output, SHA 256 hashing is used. The Secure Hashing Algorithm 256 secures it by providing the hash pre image resistance. This means that the generated content in the output hash cannot be reversed.

This allows for a different form of verification known as Proof of History, PoH. Solana uses uses this to check that an event has happened before and after another set of events. This allows for nodes to operate trust free.

In addition to the different methods of transaction verification, Solana also states that it has a theoretical limit of 710,000 transactions per second. It achieves this by a applying a method that allows for multiple transactions without causing interference known as optimistic concurrency control.

Proof of History

What's the deal?

Basically, the main difference with other systems is that, in Solana's case, validators are taking the previous output of a hash, and are feeding it into the next input. This sequence is repeated ad infinitum, essentially creating a chain of verifiable hashed transactions.

“Hey calm down, what is a hash?”
A hash function will map data to a fixed size output, here’s an example:

In here, our string “jacob” will be passed in a hashing function to then be outputted as a binary sequence.

Understand that a hash function only works one way, in our example: top to bottom. Having the binary sequence, and trying to decipher it to end up with “jacob” would not be possible.

Okay okay, I know what a hash is, and how it’s done, but then how can we know what a hash represents in the blockchain?

Compared to some other chains, where hashes can be parallelized, in here, we’re working with serialization: you cannot begin the calculations of a hash if the previous one hasn’t ended. The only thing that can be done in parralel is verification.

PoH has an interesting clock system, since the chain has every transaction being the input to the next, and hashing takes a set amount of time, we’re not using timestamps.

In another validation process such as the one use by Bitcoin, miners use local or even innacurate time. To avoid that, Solana uses hashes that link the blocks in verified succession. In a short amount of time (400ms to be exact), validators are voting on the inclusion of transactions in slots.

There is additional terminology that is commonly used to describe the operation of the Solana blockchain. To better understand these terms we suggest you take a look here here.