Blockchain Without the Buzzwords: Why Decentralized Systems Need Cryptography

Understanding the basic ideas behind blockchains, smart contracts, decentralized applications and zero-knowledge proofs

Have you ever wondered how it is possible to trust a digital system without trusting a single company, server, or authority?

This is one of the main ideas behind blockchain technology. Instead of having one central entity deciding what is valid and what is not, a blockchain allows many different participants to share and verify the same information.

However, this also creates several challenges.

How can we make sure that all participants agree on the same data? How can we protect users’ privacy if everything is publicly visible? How can we avoid forcing every participant to repeat every computation? And how can we prevent economically motivated actors from taking advantage of the system?

This is where cryptography, and in particular zero-knowledge proofs, becomes especially relevant.

In the previous article, we introduced BAobaB and its main goal: to study blockchain not as a buzzword, but as a technology that needs solid cryptographic foundations, good incentives and practical validation.

In this article, we introduce the main concepts needed to understand a set of research works related to blockchain, decentralized applications, zero-knowledge proofs, DeFi, homomorphic encryption and 5G/6G decentralization.

The goal is not to go into all the mathematical details, but to build the basic intuition needed before diving into each paper individually.

Blockchain: a shared record without a central authority

A blockchain can be understood as a shared digital ledger.

Imagine a book where transactions are written down one after another. Instead of being stored by a single institution, copies of this book are kept by many different computers. These computers, usually called nodes, follow a common protocol to decide which new transactions should be added.

Transactions are grouped into blocks, and each block is linked to the previous one. This makes it very hard to modify past information without being detected.

The main idea is simple:

A blockchain allows several parties that do not necessarily trust each other to maintain a common record.

This is useful when we want a system to operate without relying on a single trusted intermediary. Bitcoin used this idea to create digital money without a central bank. Ethereum extended it by allowing programs, called smart contracts, to run on top of the blockchain.

Are all blockchains the same?

No.

The word blockchain is sometimes used as a buzzword, but not every distributed database is a blockchain, and not every blockchain is useful for every problem. This is one of the points highlighted in the BAobaB project: before applying blockchain technology to a real use case, we need to understand what blockchain can and cannot provide.

There are different types of blockchains.

Some are public, like Bitcoin or Ethereum. Anyone can read the data and submit transactions.

Some are private or permissioned, where only selected participants can validate or access some parts of the system.

Some blockchains are mainly used to transfer value. Others, like Ethereum, allow the execution of smart contracts. This means that the blockchain does not only store transactions, but also runs code.

This is what makes decentralized applications possible.

What are decentralized applications?

A decentralized application, or dapp, is an application that runs on a blockchain or on a peer-to-peer network instead of being controlled by a single server.

In a traditional application, users usually depend on a company. The company stores the data, executes the logic, and decides how the system behaves.

In a decentralized application, part of this logic is encoded in smart contracts. These contracts are public programs that execute according to predefined rules.

This can be useful in different contexts:

• digital currencies;
• decentralized finance;
• decentralized exchanges;
• identity systems;
• distributed computing;
• IoT systems;
• 5G/6G resource management.

However, decentralization also introduces new problems. If no single entity controls the system, then the system itself must provide mechanisms to ensure correctness, privacy and security.

The main challenge: everyone must be able to verify

In a blockchain, users do not simply trust that a transaction is valid. They must be able to verify it.

This is a powerful idea, but it is also expensive.

If every node has to repeat every computation, the system becomes slow. If we want the system to scale, we need a way to prove that computations were done correctly without requiring everyone to repeat them.

This is one of the main reasons why zero-knowledge proofs and SNARKs are so important in blockchain.

They allow one party to generate a proof that a computation is correct, and another party to verify this proof efficiently.

In other words:

Instead of repeating the whole computation, we verify a short cryptographic proof.

What are zero-knowledge proofs used for in blockchain?

Before defining what a zero-knowledge proof is, let’s first see why it is useful.

In blockchain systems, zero-knowledge proofs can be used to prove that a transaction is valid without revealing all its details.

For example, a user could prove that they have enough funds to make a transaction without revealing their full balance. Or a system could prove that a batch of transactions has been processed correctly without publishing all intermediate computation steps.

Zero-knowledge proofs are also useful for scalability. If many transactions are processed outside the main blockchain, a short proof can be published on-chain to show that all of them were valid.

This is the idea behind many validity proofs and rollup systems.

Thus, zero-knowledge proofs help with two important blockchain problems:

1. Privacy, because they can hide sensitive information.
2. Scalability, because they can reduce the amount of computation that must be repeated by everyone.

What is a zero-knowledge proof?

A zero-knowledge proof is a cryptographic protocol between two parties.

One party is called the prover. This is the person or system that wants to prove something.

The other party is called the verifier. This is the person or system that checks the proof.

The prover wants to convince the verifier that a certain statement is true, without revealing the secret information that makes it true.

For example, imagine that Alice wants to prove that she knows a password, but she does not want to reveal the password itself. A zero-knowledge proof allows Alice to convince Bob that she knows it, while Bob learns nothing about the password.

A zero-knowledge proof should satisfy three main properties:

Completeness. If the statement is true, an honest prover should be able to convince the verifier.

Soundness. If the statement is false, a cheating prover should not be able to convince the verifier, except with negligible probability.

Zero-knowledge. The verifier should not learn anything beyond the fact that the statement is true.

In blockchain, the statement could be something like:

This transaction follows the rules.

And the witness — the private information used to prove the statement — could include secret values, keys, balances or intermediate computation data.

What are SNARKs?

A SNARK is a special type of cryptographic proof.

The word stands for Succinct Non-Interactive Argument of Knowledge. Although the name is technical, the main idea is not too hard to understand.

A SNARK is a proof that is:

• short;
• fast to verify;
• non-interactive, meaning that the prover usually sends just one proof to the verifier;
• able to prove knowledge of some private information.

The most important property here is succinctness.

Succinctness means that the proof can be very small and quick to verify, even if the computation being proven is very large.

This is extremely useful for blockchain. If a smart contract or a blockchain node can verify a short proof instead of re-executing a large computation, the system can become much more efficient.

This is why SNARKs are considered a key tool for blockchain scalability. They allow us to move expensive computation away from the main chain while keeping verification on-chain.

But there is an important caveat.

SNARKs make verification very efficient, but generating the proof can still be expensive. The prover may need a lot of time, memory and computational resources. This becomes a problem when we want to prove very large computations, such as many blockchain transactions or the execution of a virtual machine.

For this reason, much of the current research focuses on making proof generation more efficient.

Some techniques try to reduce the number of operations needed to generate the proof. Others try to aggregate many proofs into one. Others use recursion, where a proof can verify previous proofs.

All of these techniques try to answer the same question:

How can we prove more, while computing less?

Putting the first pieces together

We can now connect the main concepts.

A blockchain provides a shared infrastructure.

Smart contracts allow rules to be executed without a central operator.

Decentralized applications use these rules to build services such as exchanges, identity systems, distributed computing platforms or new ways of coordinating digital infrastructure.

Zero-knowledge proofs allow users to prove that something is true without revealing unnecessary information.

SNARKs make these proofs short and efficient to verify.

The common thread is that blockchain is not just about creating new digital assets. It is about building systems where users can interact in environments with limited trust, while still having strong guarantees of correctness, privacy and security.

Or, said differently:

The goal is not to remove trust completely. The goal is to replace blind trust with verifiable guarantees.

In the next article, we will look at some of the cryptographic tools that make this possible: commitments, lookup arguments, folding, recursion and homomorphic encryption.