
## Blocks

![](assets/blocks_lzrylgx.webp)

### 1. Define block in the blockchain

A block is thus a permanent store of records that, once written, cannot be altered or removed. A Block has a limited size and transaction to avoid All Block are verified on the blockchain by all nodes and stored on the blockchain Block data are batches of transactions with a hash of the previous block in the chain. This links blocks together (in a chain) because hashes are cryptographically derived from the block data. This prevents fraud, because one change in any block in history would invalidate all the following blocks as all subsequent hashes would change and everyone running the blockchain would notice.

![](assets/blocks_svihd1p.webp)

### 2. Block data

#### 2.1 Standard data

- Block height – The block number and length of the blockchain (in blocks) on creation of the current block.
- Timestamp – The time at which a miner mined the block.
- Transactions – The number of transactions included within the block.
- Miner – The address of the miner who mined the block.
- Reward – The amount of ETH awarded to the miner for adding the block (standard 2ETH reward + any transaction fees of transactions included in the block).
- Difficulty – The difficulty associated with mining the block.
- Size – The size of the data within the block (measured in bytes).
- Gas used – The total units of gas used by the transactions in the block.
- Gas limit – The total gas limits set by the transactions in the block.
- Extra data – Any extra data the miner has included in the block.

#### 2.2 Advanced data

- Hash - The cryptographic hash that represents the block header (the unique identifier of the block).
- Parent hash – The hash of the block that came before the current block.
- Sha3Uncles – The combined hash of all uncles for a given parent.
- StateRoot – The root hash of Merkle trie which stores the entire state of the system.
- Nonce – A value used to demonstrate proof-of-work for a block by the miner.

#### 2.3 Uncle blocks

Uncle blocks are created when two miners create blocks at near-enough the same time – only one block can be validated across the nodes. They are not included but still receive a reward for the work.

Block explorers provide information about uncle blocks like:

- An uncle block number.
- A time they occurred.
- The block height at which they were created.
- Who mined it.
- The ETH reward.

![](assets/blocks_eqhpghw.webp)

### 3. Block Time

Block time refers to the time it takes to mine a new block. In Ethereum, the average block time is between 12 to 14 seconds and is evaluated after each block. The expected block time is set as a constant at the protocol level and is used to protect the network's security when the miners add more computational power. The average block time gets compared with the expected block time, and if the average block time is higher, then the difficulty is decreased in the block header. If the average block time is smaller, then the difficulty in the block header will be increased.

A new block can be rejected, please be careful with the new block, You need to wait for maximum node to verify this block before use.

### 4. Block Size

A final important note is that blocks themselves are bounded in size. Each block has a target size of 15 million gas but the size of blocks will increase or decrease in accordance with network demands, up until the block limit of 30 million gas (2x target block size). The total amount of gas extended by all transactions in the block must be less than the block gas limit. This is important because it ensures that blocks can’t be arbitrarily large. If blocks could be arbitrarily large, then less performant full nodes would stop being able to keep up with the network due to space and speed requirements.

### 5. Mining's Relationship to Blocks

Mining is the term used for solving the number that is the nonce, the only number that can be changed in a block header. It is also the process the cryptocurrency's network uses if proof-of-work is used in the protocol.

![](assets/blocks_qi5jtrd.png.webp)

Cryptocurrency mining is commonly thought to be a complex mathematical problem; it is actually a random number generated through hashing. Hashing is the process of encrypting information using the encryption method a cryptocurrency uses. For example, Bitcoin uses SHA256 for its encryption algorithm. For a miner to generate the "winning" number, the mining program must use SHA 256 to hash random numbers and place them into the nonce to see if it is a match.

### 6 Gas in block

Gas is used to estimate the difficulty of all transactions in the block. Every function in a smart contract or transaction on blockchain will pay gas to process. To submit a transaction and avoid miners delaying your transaction forever, you need to pay enough gas Gas = Gas used \* Gas ​​price

#### Reference

https://ethereum.org/en/developers/docs/blocks/


This article provides an overview of blocks in blockchain technology, including their structure, types, and how they work.

Blocks


![](assets/blockruption-blockchain-300h.png)

## Distributed systems on blockchain

As defined on Wiki, distributed computing is a branch of computer science that studies distributed systems. A distributed system is a software system whose components are located on different computers, connected in a network. These computers work together as a single entity to accomplish a common task by exchanging messages. Distributed computing is decentralized parallel computing. The types of hardware, programming languages, operating systems, and other resources used can vary widely. It is similar to computer clustering with the main difference being the geographical distribution of resources.

Distributed systems appear to be very common in practice. Most applications today, especially Internet applications, are implemented as Distributed systems. Deploying software, especially large systems, on multiple computing units (instead of using a single computer) has many benefits, such as:

- Provide more resources when the system needs to handle a larger amount of work.
- Using only one computer unit means the risk of software crashing (crash) if that machine has a problem. Using multiple machine units will allow you to continue operating the software even if problems occur.
- When your system becomes complex and requires the combination of many different components, using DS allows you to break down a large system into many small units. Each unit can operate independently, can even be developed by different teams with different expertise.

System users may be geographically dispersed across the globe. To ensure quality of service and limit latency, the machine system also needs to be distributed so that it can be as close to the user as possible.

## Advantages of distributed systems:

- Scalability: There are two types of scaling: horizontal scaling and vertical scaling:
- Reliability: Reliability is the fault tolerance of the system which means that the system will continue to provide its service as soon as one or more components (software/hardware) of the system fail.
- Availability: is the total time a system remains in normal operation for a specific period of time. A measure of availability is the percentage of time the system is up and running continuously for a period of time (usually 1 year).
- Efficiency: The efficiency of a distributed system is high load and low latency. This means that a system that can handle many concurrent requests with low latency is a high-performance system.
- Manageability: it is the ability to easily expand and maintain the system. In other words, it is the time to perform repair (repair) or maintain (maintain) when needed, the higher the time, the lower the availability.

## Machine failure (node failure)

Each physical computer, due to various reasons, can experience problems while in operation. These incidents are divided into several main categories:

- Fail-stop: This is a type of problem that causes the process on the machine to stop working (stops computation as well as communication). The cause of this problem can be due to the machine crashing (software error, operating system error ...), hardware failure, or external causes (eg power failure). This is the most common type of problem, so when people talk about 'failure' without saying anything else, it's usually implied as this type of problem. Most of the algorithms developed in DS are intended to deal with this type of problem.
- Fail-recover: Process may be down for a certain time, but then recovery works again. The cause of this type of problem can be due to the machine rebooting automatically for some reason. Often when talking about this type of failure, people assume that the machine has the ability to store information on the hard drive and recover this information after the failure occurs.
- Byzantine failure: The problem that the computer does not work according to the requirements set forth. For example, the machine can send arbitrary messages, or change state arbitrarily, unlike what is programmed. This is the most annoying type of problem, which can happen when the system crashes for no apparent reason (e.g. RAM may be damaged causing bit-flip), or because the system is attacked by malicious actors. .

## Network problems

![](assets/How-Does-YugaByte-DB-Handle-Network-Partitions-and-Failover-blogpreview.png)

A computer network is also a physical product and so problems can also occur. A common type of problem is the “network partitioning” problem, which is simulated by the figure above. This problem occurs when the transmission of one or more servers is cut off from the rest of the system, causing the system to be split into many parts that cannot communicate with each other. In fact, in data centers, a cluster of servers is usually connected by one or more switches. Failure of the switch port or wire can lead to one or more servers being disconnected, leading to the aforementioned partitioning situation.

## Distributed systems in blockchain

![](assets/distributed-systems_c7xyhh1.webp) Blockchain is a distributed ledger, which simply means that a ledger is spread across the network among all peers (nodes) in the network. Every node has a copy of the Blockchain and once a block reaches a certain number of approved transactions then a new block is formed

Any computer can join the blockchain network and become a validator by connecting to the internet and launching applications. The difference is that to become a node on the network, a computer needs to meet certain requirements in terms of connection speed, storage speed, and storage space. For the current bitcoin network, due to too many miners participating in the operation, the network requires a huge amount of computing power, If you want to participate in the network you need to run the service through the mines to contribute strength.

## Distributed software on blockchain

"The Ethereum Virtual Machine ([evm]()) is the runtime environment for transaction execution in Ethereum. It includes a stack, memory, gas balance (see below), program counter, and the persistent storage for all accounts (including contract code). When a transaction calls a contract's function, the arguments in the call are added to the stack and the EVM translates the contract's bytecode into stack operations. Stack items may be stored in memory or storage, and data from memory/storage may be added to the stack. The EVM is isolated from the other files and processes on the node's computer to ensure that for a given pre-transaction state and transaction, every node produces the same post-transaction state, thus enabling network consensus such as [pos](). The formal definition of the EVM is specified in the Ethereum Yellow Paper. EVMs have been implemented in C++, C#, Go, Haskell, Java, JavaScript, Python, Ruby, Rust, Elixir, Erlang, and soon WebAssembly."

The EVM's instruction set is Turing-complete. Popular uses of Ethereum have included the creation of fungible (ERC20) and non-fungible (ERC721) tokens with a variety of properties, crowdfunding (e.g. initial coin offerings), decentralized finance, decentralized exchanges, decentralized autonomous organizations (DAOs), games, prediction markets, and gambling.

## How about scale for blockchain ?

Concerning pure computing power, distributed computing offers easier scalability than centralized computing. It's relatively easy to add more machines to gain more computing power and reduce them when power needs are lower.

However, blockchain has different scalability issues. In a blockchain, the number of transactions processed in a fixed period limits transaction speed. Therefore, the scalability issue is one of transaction speed. This scalability limitation is due to the need for the nodes in a blockchain to reach consensus on the transactions taking place. Therefore, while distributed computing itself offers a high degree of scalability, the game theory element of blockchain is generally what hampers scalability on transaction speeds.

This gives rise to a concept of difficulty, Once there are too many computers involved in processing the transaction. The network will change the difficulty to reduce contention. The computer will have to calculate with higher difficulty.

The downside is that performance issues arise because every node calculates all the smart contracts in real-time. As of January 2016, the Ethereum protocol could process about 25 transactions per second. In comparison, the Visa payment platform processes 45,000 payments per second. The next Ethereum 2.0 can serve more than 100.000 transactions

Today we have a series of solutions to improve transaction speed on ethereum such as: Layer 2.

## Reference

https://en.wikipedia.org/wiki/Ethereum https://www.youtube.com/user/cbcolohan https://www.worldbank.org/en/topic/financialsector/brief/blockchain-dlt https://en.wikipedia.org/wiki/Distributed_ledger https://www.youtube.com/playlist?list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB


This article provides an overview of distributed systems in blockchain technology, including their definition, advantages, and how they work.

Distributed systems


## The Proof of Stake

The Proof of Stake consensus algorithm was introduced in 2011 on the Bitcointalk forum to solve the problems of the most popular algorithm in use – Proof of Work. . While both share the same goal of achieving consensus in the blockchain, the process to achieve the goal is quite different. where the nodes of a blockchain-based network must "stake" a sum of money or tokens (proving their identity) in order to participate in the verification of transactions in a block.

Just like proof of work, proof of stake is designed to achieve distributed consensus on the valid order of transactions - i.e. reach agreement on a single shared version of history .

PoS indicates that a person can mine or confirm block transactions according to the amount of coins he or she holds. This means that the more Bitcoins or tokens owned by a miner, the more mining power will be available.

The first cryptocurrency to adopt the PoS method was Peercoin. Nxt, Blackcoin and then ShadowCoin.

![](assets/pos_jouvtnm.png.webp)

## How proof of stake works

The Proof of Stake algorithm uses a pseudo-random election process to select a node as the validator of the next block, based on a combination of factors that may include staking age, random and the size of the button. Users who wish to participate in this process must lock a certain number of native tokens into the network as their stake. The size of the stake determines the chance for a node to be selected as a validator to generate the next block – the larger the stake, the greater the chance. In order for the process not only to prioritize the wealthiest nodes in the network, unique methods are added to the selection process. The two most commonly used methods are 'Random Block Selection' and 'Coin Age Selection'. In the Random Block Pick method, validators are selected by looking for nodes with the combination of the lowest hash value and the highest stake, and since the stake size is public, the validator node The next real thing can usually be predicted by other nodes. The Coin Age Selection method selects nodes based on how long their coins have been staked. Coin age is calculated by multiplying the number of days the coin is held by the number of coins staked. When a node forges a block, their coin age is reset to zero and they have to wait a certain amount of time before they can generate another block – this prevents large stake nodes from dominating the blockchain.

Each native token that uses the Proof of Stake algorithm has its own set of rules and methods to create the best combination for them and their users.

When a node is selected to generate the next block, it checks if the transactions in the block are valid, signs the block, and adds it to the blockchain. The node receives the transaction fees associated with the transactions in the block.

If a node wants to stop working as a blacksmith, its staked coins along with the rewards earned are released after a certain amount of time, giving the network time to verify that no fraudulent blocks were added by that node. into the blockchain.

Proof of stake was created as an alternative to proof of work (PoW), to solve the inherent problems of computation time and energy consumption when using PoW.

PoS seeks to solve the problem by reducing mining power to the percentage of coins a miner spends to join the nodes. This way, instead of using energy to solve the PoW problem, PoS miners are limited to mining by a transaction rate that reflects the number of shares the miner owns. For example, a miner who owns 3% of Bitcoins could theoretically only mine 3% of those blocks.

#### Compare PoW and PoS

![](assets/pos_xiuwh4m.png.webp)

## About security

The stake coin acts as a financial incentive for the forging node to not validate or generate fraudulent transactions. If the network detects a fraudulent transaction, the forging node will lose part of its stake and the right to participate in future block forging. So as long as the stake is higher than the reward, validators will lose more coins than they would have gained in case of a fraud attempt.

To effectively control the network and approve fraudulent transactions, a node would have to own a majority stake in the network, this is known as a 51% attack. Depending on the value of the native token, this would be very impractical as to gain control of the network you would need to have more than 51% of the circulating supply.

In 2017, Ethereum (ETH) started its full transition from PoW to PoS system and by 2022 it has successfully deployed on Ropsten testnet.

## Advantages of PoS:

- Fast transaction processing.
- PoS does not harm the environment.
- Not vulnerable to government attacks: don't need huge amounts of electricity.
- Can be performed on smaller and weaker devices because there is no need to download the entire blockchain, and because it does not require a lot of computing power, it can be


This article provides an overview of Proof of Stake (PoS) in blockchain technology, including its definition, how it works, and its advantages.


## Smart contracts

Smart contracts, also known as smart contracts, are computer programs that operate on the blockchain. Entities interacting with the contract do not need to know each other or trust each other.

- The contract ensures that with the conditions of the contract satisfied, the contract will be executed
- The logic of the contract can be verified. In other words, a smart contract is an intermediary, greatly reducing operating costs if you do it in real life: for example, if you buy a house, you must notarize it, then pay. money at the notary office, then go to the real estate office to do the account transfer procedure... it will need many steps involving people and intermediaries. If you make this purchase on a smart contract, you will simply create a home sale transaction and one buyer will create a purchase transaction, the other contract will perform the transfer of money, change ownership, related information, and sales history.

## How smart contract work:

- Developer distributes contract on the blockchain
- The user signs the transaction and invokes the contract on the blockchain
- Contract processes data and executes commands
- The data after being executed will be saved on the blockchain

## Structure of a smart contract:

- Declare solidity version
- Declare libraries, interfaces
- Declare variables
- Declare constructor
- Processing instructions
- Save state
- Event/Log

![](assets/Voie7xm.png)

Declare variable ![](assets/2ADeNxC.png)

Function/Instruction ![](assets/izkaluC.png)

Event/Log ![](assets/mTMfjdI.png)

## Invoke another smart contract:

Currently, Ethereum there are many contracts such as tokens, NFT-ERC721, games, swaps, lending... To work directly with these contracts you can make calls directly from your application from javascript or go lang via ABI, ABI is an interface type similar to API specification file or description file. describe swagger. It defines data objects and callable functions. Or you can also call the interface of another contract in your contract for example:

- Declare interface
- Call command

![](assets/ezVDghs.png)

## The advantages of smart contracts:

- Efficiency: Smart contracts promise to automate business processes at a corporate level. This reduces operating costs and saves resources, including the staff needed to oversee complex operations involving multiple companies.
- Processing speed: Smart contracts help improve the processing speed of processes between many different companies and corporations.
- Autonomy: Smart contracts are executed automatically by a network and help reduce the need for a 3rd party to manage transactions between companies.
- Reliability: Smart contracts also leverage blockchain ledger and other distributed ledger technologies to store all the information and operations involved in complex processing after it has been executed presently. This technology also supports automated trading which eliminates human errors and ensures accuracy in contract execution.

## The limitations of smart contracts:

- Security issues: Smart contracts play certain important roles in a business involving many parties. However, this technology is still new and hackers are constantly exploiting new attack directions to penetrate. In the early days of Ethereum, hackers hacked and stole a large amount of virtual currency worth $50 million. The IEEE Consortium of Electrical and Electronic Engineers has also expressed concern about the weakness of the tools used to detect vulnerabilities in smart contracts.
- Integrity: An oracle (a data source that sends event updates) should be protected from hackers creating fake events to trigger the processing of contracts even though they are not allowed. The system needs to be programmed to generate the correct events, which can be quite difficult in complex cases.
- Relevancy: Smart contracts can speed up processing in a multi-party contract regardless of whether it matches the intent or understanding of all parties. But it can also add to the damage in the event things get out of hand, especially when there's no way to stop or reverse the unintended actions. Research firm Gartner has pointed out that this creates a challenge in the management of smart contracts, although this challenge has not been fully addressed.
- Complexity in management: Smart contracts are quite complicated in deployment and management. They are often designed in such a way that it is very difficult or impossible to change. Although this increases security, the parties will not be able to change the content or add new terms without creating a new contract.

Take for example a smart contract when deployed When a Decentralized Autonomous Organization (DAO) named "The DAO" was hacked in 2016, millions of ETH were stolen due to a mistake in their smart contract code. Since their Smart Contract is immutable, developers cannot edit the code. This eventually led to a hard fork, creating Ethereum Classic and Ethereum.

#### Reference

https://ethereum.org/vi/developers/docs/smart-contracts/


This article provides an overview of smart contracts in blockchain technology, including their definition, how they work, and their advantages.

Smart Contract


- [Blocks](blocks.md)
- [Distributed System](distributed-systems.md)
- [Smart contract](smart-contract.md)
- [Zero-knowledge Proofs](./zero-knowledge-proofs.md)
- [PoW & PoS](pos.md)


This article provides an overview of the key topics in blockchain technology, including blocks, distributed systems, smart contracts, and zero-knowledge proofs.

Topics


Zero-knowledge proof is a way of proving the validity of a statement without disclosing the statement itself. A "validator" is the party attempting to prove a claim, while a "verifier" is responsible for validating the claim.

## Why do we need to demonstrate no knowledge?

Zero-knowledge proofs represent a breakthrough in applied cryptography, as they promise to improve the security of information for individuals. Consider how you can prove the claim (for example, “I am a citizen of country X”) to another party (for example, a service provider). You'll need to provide "proof" to back up your claim, such as a national passport or driver's license. But this approach is not safe, can be hacked, personal information can be revealed

Zero-knowledge proofs solve this problem by removing the need to disclose information to prove the validity of claims. The zero-knowledge protocol uses a statement (called a 'witness') as input to generate a succint proof of its validity. This proof provides firm assurance that a statement is true without revealing the information used to make it.

Going back to our earlier example, the only proof you need to prove your citizenship claim is zero-knowledge proof. The verifier only has to check if certain properties of the proof are true to believe that the underlying statement is also true.

## How to prove Zero Knowledge works?

To make this possible, zero-knowledge protocols rely on algorithms that take some data as input and return the 'true' or 'false' as output. A Zero-knowledge protocol must satisfy the following criteria:

1. **Completeness**: If the input is valid, the zero-knowledge protocol always returns 'true'. Hence, if the underlying statement is true, and the prover and verifier act honestly, the proof can be accepted.
2. **Soundness**: If the input is invalid, it is theoretically impossible to fool the zero-knowledge protocol to return 'true'. Hence, a lying prover cannot trick an honest verifier into believing an invalid statement is valid (except with a tiny margin of probability).
3. **Zero-knowledge**: The verifier learns nothing about a statement beyond its validity or falsity (they have “zero knowledge” of the statement). This requirement also prevents the verifier from deriving the original input (the statement’s contents) from the proof.

In basic form, a zero-knowledge proof is made up of three elements: witness, challenge, and response.

- **Witness**: with a zero-knowledge proof, the prover wants to prove knowledge of some hidden information. the secret information is the "witness" to the proof, and the prover's assumed knowledge of the witness establishes a set of questions that can only be answered by a party with knowledge of the information. Thus, the prover starts the proving process by randomly choosing a question, calculating the answer, and sending it to the verifier.
- **Challenge**: The verifier randomly picks another question from the set and ask the prover to answer it.
- **Response**: the prover accepts the question, calculates the answer and returns it to the verifier. The prover's response allows the verifier to check if the former really has access to the witness. to ensure the prover is not guessing blindly and getting the correct answers by chance, the verifier pick more question to ask. By repeating this interaction many times, the possibility of the prover faking knowledge of the witness drops significant until the verifier is satisfied.

Interactive proof and non-interactive proof:

- Interactive proof had limited usefulness since it required the two parties to be available and interact repeatedly
- Non-interactive proof required only one round of communication between participants. the provers passes the secret information to a special algorithm to compute a zero-knowledge proof. this proof is sent to the verifier, who verify that the prover knows the secret information using other algorithm.

## Types of zero-knowledge proofs

### ZK-SNARKs

ZK-SNARK is an acronym for Zero-Knowledge Succinct Non-Interactive Argument of Knowledge. The ZK-SNARK protocol has the following qualities:

- **Zero-knowledge**: A verifier can validate the integrity of a statement without knowing anything else about the statement. The only knowledge the verifier has of the statement is whether it is true or false.
- **Succinct**: The zero-knowledge proof is smaller than the witness and can be verified quickly.
- **Non-interactive**: The proof is 'non-interactive' because the prover and verifier only interact once, unlike interactive proofs that require multiple rounds of communication.
- **Witness**: The proof satisfies the 'soundness' requirement, so cheating is extremely unlikely.
- **(Of) Knowledge**: The zero-knowledge proof cannot be constructed without access to the secret information (witness). It is difficult, if not impossible, for a prover who doesn’t have the witness to compute a valid zero-knowledge proof.

For the ZK-SNARK protocol to work, the creation of a Common Reference String (CRS) is necessary: ​​The CRS provides public parameters to prove and verify valid proofs. The security of the proof system depends on the CRS setting; If the information used to create the public parameters falls into the possession of malicious actors, they can create false validators.

- Some ZK-rollups attempt to solve this problem by using multiparty computation (MPC), involving trusted individuals, to create public parameters for the ZK-SNARK circuit. Each party contributes a random number (called "hazardous waste") to the construction of the CRS, which they must destroy immediately.
- Trusted settings are used because they increase the security of the CRS setup. As long as an honest participant discards their input, the security of the ZK-SNARK system is guaranteed. However, this approach still requires the trust of the stakeholders to erase their sampled randomness and not undermine the security guarantees of the system.
- Reliability assumptions aside, ZK-SNARK is very popular because of its small proof size and continuous time verification. Since verifying proofs on L1 constitutes a greater operating cost of ZK-rollup, L2 uses ZK-SNARK to generate proofs that can be quickly and cheaply verified on the Mainnet.

### ZK-STARKs

Like ZK-SNARKs, ZK-STARKs demonstrate the validity of off-chain computation without revealing the input. However, ZK-STARK is considered an improvement on ZK-SNARK because of their scalability and transparency.

- **Scalable**: ZK-STARK is faster than ZK-SNARK in generating and verifying evidence when witness size is larger. With STARK proofs, verification and proverb times only increase slightly as the witness grows (the times of the proverb and SNARK verifier increase linearly with witness size).
- **Transparency**: ZK-STARK relies on public verifiable randomness to generate public parameters for proof and verification instead of establishing trust. Therefore, they are more transparent than ZK-SNARK.
- **Scalability**:ZK-STARKs also offer more scalability because the time required to prove and verify valid proofs increases with the complexity of the underlying computation. With ZK-SNARK, the proof and verification times expand linearly with respect to the size of the underlying computation. This means that ZK-STARK requires less time than ZK-SNARK to prove and verify as far as large data sets are concerned, making them useful for high volume applications.
- **Security**: ZK-STARK is also secure against quantum computers, while Elliptic Curve Cryptography (ECC) used in ZK-SNARK is considered by many to be vulnerable to quantum computing attacks. The downside of ZK-STARKs is that they produce a larger proof size, which is more expensive to verify on Ethereum. Also, they don't support recursion, which is key to extending off-chain computation with zero-knowledge proofs.

## Application for ZK proof

- Anonymous payments
- Identity protection
- Authentication
- Verifiable computation

## Drawbacks of using ZK proofs

- Hardware costs
- Proof verification costs
- Trust assumptions
- Quantum computing threats

## References

- [Zero-knowledge proofs](https://ethereum.org/en/zero-knowledge-proofs/)
- [ZL-Rollup](https://docs.ethhub.io/ethereum-roadmap/layer-2-scaling/zk-rollups/)
- [ZK-SNARKs](https://medium.com/coinmonks/zk-snarks-a-realistic-zero-knowledge-example-and-deep-dive-c5e6eaa7131c)
- [ZK-STARKs](https://medium.com/coinmonks/zk-starks-create-verifiable-trust-even-against-quantum-computers-dd9c6a2bb13d)
- [Snarks-vs-starks](https://www.alchemy.com/overviews/snarks-vs-starks)


This article provides an overview of zero-knowledge proofs in blockchain technology, including their definition, how they work, and their advantages.

Playground > Blockchain > Foundational Topics