The Heartbeat of Cardano.

The Basho Era: Scalability for Cardano in 2022

Cardano evolves through eras, and each one has its theme, Byron was the foundation, Shelley was decentralization, Goguen was programming smart contracts, Voltaire was governance, and Basho was scalability.

Each era marks a new milestone in development, but they all progress in parallel, you don’t need to completely finish one to start another, moreover, I would say that they are all always in constant progress and improvement. This year, 2022, is the year of Basho. 

With the Hard Fork Alonzo and the enablement for programming in the Plutus language, it was possible to develop DApps for DeFi. 

Although with the NFT airdrops there were spikes in network congestion, the significant and continuous increase in transactional traffic began to be noticed with the appearance of DEXes, MuesliSwap, SundaeSwap and recently ADAX. 

As major components, including wallet connectors and the Plutus Application Backend (PAB), are finalized and integrated into the mainnet, further activity is anticipated. 

With current parameters, the Cardano network is using, on average, around 90% of its capacity. 

All of this demonstrates the need to improve network scalability, which means processing transactions faster, with lower latency, and without increasing cost.

Part of the scalability is block propagation, which is the time it takes for a newly minted block to be transmitted through nodes on the network. In order for the blockchain to remain secure, the current protocol, Ouroboros Praos, propagates new blocks every 5 seconds.

There is also the block time budget, which is a fixed amount of time available to process all the transactions included in a single block. This is divided between the time that can be used for the execution of the Plutus script and the time that is available to execute other transactions. It is currently set to 1 second. 

For security reasons, the Praos consensus protocol selects only a small fraction of the blocks (1 in 20) that could potentially be added to the chain. For current protocol parameters, the maximum transaction throughput (for simple transactions) is approximately 11 transactions per second (TPS).  

By using a fixed-size mempool (a repository that stores transactions waiting to be processed), the possibility of nodes being overloaded during periods of high demand is avoided, but it does mean that a wallet or application may need to return to send transactions. The mempool size is currently set to twice the current block size. 

Ethereum is creating 80 KB blocks every 13 seconds, Cardano 74 KB blocks every 20 seconds, so we have around 3.7MB moved on the network for Ethereum and 2.1MB for Cardano every 10 minutes.

Currently, due to Plutus’ rather large transactions, Cardano’s network efficiency is slightly lower than Ethereum’s, before Plutus’ script optimizations are implemented.

Basho: IOHK Proposes a Scalability Plan

An important feature of the Cardano protocol is that it has been designed with true scalability in mind, with flexibility being key to this.

IOHK proposes gradual and methodical changes in the parameters, and then to monitor the results in the network as the plan advances, which I will detail below. 

Parameter adjustment 

The first adjustment made recently was to increase the block size by 12.5%, from 64 KB to 72 KB. There are almost 3 million Cardano wallets in use, and traffic has grown almost 20 times (from less than 10,000 transactions per day in November 2020 to almost 200,000 per day this year). Larger blocks fit more transactions, providing more capacity for users.

The second adjustment made was the increase in Plutus script memory units per transaction to 11.25 million, again an increase of 12.5%. This is a powerful change that is greatly appreciated by DApp developers. An increase in Plutus memory limits means that you can develop more sophisticated Plutus scripts, or that existing scripts will be able to process more data items, increase concurrency, or expand their capabilities. 

Also, days ago, improvements to the central node software were implemented with the recent version 1.33.0, which is executed by the stakepool operators for the consensus of the blockchain, with new improvements, and now the blocks propagate faster and with less RAM requirements (about 1 GB less), due to two factors: memory compaction and more efficient memory sharing (instead of multiple instances of the same object, now multiple threads within the system will use the same object ).

Later this year, more significant improvements to the node are promised, such as the pipeline. This technique will merge block validation and propagation. Instead of going through the process of getting a header, validating it, then getting its corresponding block, validating it, and then sending it to the peer, it will get a header, validate it, and send it to the peer, without actually validating the block. This simplification will give the network even more room to make further changes. Pipelining will significantly increase the scope/headroom we have to make further improvements to the network by reducing block propagation overhead (“dead time”).

Input Endorsers

Input endorsers improve block propagation times and throughput by allowing transactions to be separated into pre-constructed blocks. This improves the consistency of block propagation times and allows higher transaction rates.

Plutus Script Improvements

Through smart contract optimization, even more effective use of the powerful eUTXO (Unspent Transaction Output) model will be achieved, which includes three Cardano Improvement Proposals (CIPs):

  • Reference Entries (CIP-0031): Plutus scripts can inspect transaction inputs without spending them. This means that it is not necessary to create UTXOs simply to inspect the information contained in an entry.
  • Plutus Datums (CIP-0032): Data can be attached directly to outputs instead of data hashes. This simplifies how the data is used, as a user can see the actual data instead of having to supply the data that matches the given hash.
  • Script Sharing (CIP-0033) – Plutus script references can be associated with transaction outputs, meaning they can be written on-chain for later reuse. It will not be necessary to provide a copy of the script with each transaction, which greatly reduces friction for developers. Reusing scripts across multiple transactions significantly reduces transaction size, which improves performance and lowers script execution costs. According to estimates by some developers, with CIP-0033 and script compression, Plutus Scripts can be reduced to about 2 KB on average.


A sidechain is an independent blockchain connected to a main blockchain, the blockchain, through a two-way mechanism, a bridge, that allows tokens and other digital assets from one chain to be used on another. A single mainchain can have multiple interoperable sidechains connected to it, which can operate in completely different ways. EVM sidechains coming to Cardano include dcSpark’s Milkomeda and IOG’s Mamba.


Hydra is the second layer solution, based on an eUTxO model that allows the delegation space to be fragmented without the need to fragment the general ledger. It introduces isomorphic state channels to maximize performance, minimize latency, incur little or no cost, and greatly reduce storage requirements. 

Hydra provides a more efficient means of processing off-chain transactions while using the main chain ledger as the secure settlement layer. 

If you want to know more about Hydra, you can read my article cited at the end (1).

Off-chain computing 

The offloading of some of the calculations, for example, with Asynchronous Contract Execution (ACE), can drive greater core network efficiency. Transactions occur outside of the blockchain itself, but can offer fast and cheap transactions through a trusted model.


Mithril is the cryptographic construct that allows thin clients (such as non-node wallets) to obtain data from the blockchain, without downloading all of its content.

Synchronizing the blockchain is an intensive operation, because it is a very large information base (currently almost 28 GB), and it is constantly growing. The main problem is to extract only a certain part of the information from the network, for a thin client (without downloading the entire blockchain).

Cryptocurrency holders will include the Mithril keys along with the basic crypto keys (in their wallets). The blockchain will contain the information of UTxOs, the information of the registered accounts, and the Mithril keys.

At regular intervals, the full nodes will collect the UTxOs, and test where they can produce a pre-signature. This test is essential, since not all holders are eligible to issue the signature on a given message, only one set will be chosen at random. Only when there is a sufficient number of pre-signature fragments, which are issued by those chosen, will it be possible to add said fragments to the final “Sigma” signature.

This will improve chain synchronization while maintaining trust, with multi-signature aggregation, which is a fast and efficient way of logging, without compromising security features. 

Hard Fork Babbage

Input Output software engineer, Kevin Hammond, commented on Cardano’s next steps, revealing that IOHK has a Hard Fork scheduled for February called Babbage, named after mathematician Charles Babbage, considered the father of computers.

With various performance improvements to the blockchain, which have been in the works for a considerable time, performance issues will be addressed. The Plutus language will also be receiving a significant update. 

The following changes are detailed on Github


  • a single VRF check
  • removal of protocol params: d and extra entropy
  • no overlay schedule / OBFT


  • collateral return output (including the total collateral field)
  • reference inputs
  • Inline datums
  • reference scripts
  • fix one or both reward calculation warts from the Shelley spec errata.

Final Words

The difficult balance of growing in an orderly and efficient way is not foreign to Cardano. Scalability is critical for growth and adoption.

Being a permissionless network, independent developers are building their products without pause, with releases that we will see more and more frequently, and although this is desirable, it highlights the urgent need to reduce transaction processing times in the blockchain system.

With the scientific rigor that characterizes Charles Hoskinson, co-founder of IOHK, and his team, peer review, and the large number of research papers they have published, the “measure twice to cut once” philosophy is more that known in them.

The planning that I have told you in this article only shows one way, this 2022 will be the year of Basho.

(1) IOHK Presents Hydra: A Scaling Solution for Cardano.

1 comment
Leave a Reply

Your email address will not be published.

Related Posts