Consensus mechanisms overview in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this simplified Proof of Work simulation?

This Python code simulates a simple Proof of Work by finding a nonce that makes the hash start with '00'. What will it print?

Blockchain / Solidity

import hashlib

def proof_of_work(data):
    nonce = 0
    while True:
        text = f'{data}{nonce}'
        hash_result = hashlib.sha256(text.encode()).hexdigest()
        if hash_result.startswith('00'):
            return nonce
        nonce += 1

nonce_found = proof_of_work('blockchain')
print(nonce_found)

A It runs forever without finding a nonce

B 0

C 1024

D 523

💡 Hint

Try running the code or understand that the nonce is the smallest number making the hash start with '00'.

The code increments nonce until the SHA-256 hash of 'blockchain' plus nonce starts with '00'. The first such nonce is 523.

🧠 Conceptual

intermediate

Which consensus mechanism uses voting among a fixed set of validators?

In blockchain, which consensus mechanism relies on a fixed group of trusted validators voting to agree on the next block?

A Practical Byzantine Fault Tolerance (PBFT)

B Proof of Stake (PoS)

C Proof of Work (PoW)

D Proof of Authority (PoA)

💡 Hint

Think about consensus designed for permissioned blockchains with known validators.

PBFT uses a fixed set of validators who vote to reach consensus, suitable for permissioned blockchains.

❓ Predict Output

advanced

What error does this Proof of Stake validator selection code raise?

Consider this Python code that selects a validator weighted by stake. What error will it raise when run?

Blockchain / Solidity

import random

validators = {'Alice': 50, 'Bob': 30, 'Charlie': 20}

weights = list(validators.values())
selected = random.choices(list(validators.keys()), weights=weights, k=1)
print(selected[0])

# Now test with an empty validators dict
validators = {}
weights = list(validators.values())
selected = random.choices(list(validators.keys()), weights=weights, k=1)
print(selected[0])

A IndexError: list index out of range

B ValueError: weights must be non-negative and not all zero

C TypeError: 'dict_keys' object is not subscriptable

D No error, prints a random validator

💡 Hint

What happens if you try to pick weighted choices from an empty list?

random.choices raises ValueError if weights are empty or all zero, which happens when validators dict is empty.

🧠 Conceptual

advanced

Which consensus mechanism is most energy efficient and uses token ownership to decide block creation?

Among these consensus methods, which one is known for low energy use and selects block creators based on how many tokens they own?

A Proof of Stake (PoS)

B Proof of Work (PoW)

C Delegated Proof of Stake (DPoS)

D Proof of Authority (PoA)

💡 Hint

Think about the method that replaces mining with stake-based selection.

Proof of Stake uses token ownership to select validators, avoiding energy-heavy mining.

❓ Predict Output

expert

What is the length of the blockchain list after running this simplified block addition code?

This Python code simulates adding blocks with a simple consensus check. How many blocks will the blockchain contain at the end?

Blockchain / Solidity

blockchain = ['Genesis']

class Block:
    def __init__(self, data, prev_hash):
        self.data = data
        self.prev_hash = prev_hash

    def hash(self):
        return hash((self.data, self.prev_hash))

# Simulate adding blocks only if prev_hash matches last block's hash
for i in range(1, 6):
    last_block = blockchain[-1]
    last_hash = hash(last_block) if isinstance(last_block, str) else last_block.hash()
    new_block = Block(f'Data {i}', last_hash)
    # Consensus check: accept block only if prev_hash matches last_hash
    if new_block.prev_hash == last_hash:
        blockchain.append(new_block)

print(len(blockchain))

A 5

B 1

C 6

D 0

💡 Hint

Count the genesis block plus all accepted blocks.

The genesis block is first. Each new block's prev_hash matches last block's hash, so all 5 blocks are added. Total length is 6.

Practice

1. Which of the following best describes the main purpose of a consensus mechanism in blockchain?

easy

A. To store large files on the blockchain

B. To speed up internet connections

C. To help multiple computers agree on a single version of data

D. To encrypt messages between users

Solution

1. Step 1: Understand the role of consensus

   Consensus mechanisms ensure all participants agree on the same data state.

2. Step 2: Compare options

   Only To help multiple computers agree on a single version of data describes agreement on data; others describe unrelated functions.

3. Final Answer:

   To help multiple computers agree on a single version of data -> Option C

4. Quick Check:

   Consensus = Agreement [OK]

Hint: Consensus means agreement among many computers [OK]

Common Mistakes:

• Confusing consensus with encryption
• Thinking consensus speeds up internet
• Mixing storage with agreement

2. Which syntax correctly names a popular consensus mechanism used in many blockchains?

easy

A. Proof of Walk

B. Proof of Work

C. Proof of Wait

D. Proof of Watch

Solution

1. Step 1: Recall common consensus names

   Proof of Work is a widely used consensus mechanism name.

2. Step 2: Check spelling and meaning

   Options B, C, and D are incorrect or made-up terms.

3. Final Answer:

   Proof of Work -> Option B

4. Quick Check:

   Correct name = Proof of Work [OK]

Hint: Remember the exact phrase: Proof of Work [OK]

Common Mistakes:

• Misspelling 'Work' as 'Walk' or 'Wait'
• Confusing similar-sounding words
• Assuming all options are valid

3. Consider this simplified pseudocode for a blockchain consensus check:

if node_vote > 50%:
    accept_block = True
else:
    accept_block = False
print(accept_block)

What will be printed if node_vote is 45?

medium

A. False

B. True

C. SyntaxError

D. None

Solution

1. Step 1: Evaluate the condition with node_vote = 45

   45 is not greater than 50%, so condition is False.

2. Step 2: Determine the value of accept_block

   Since condition is False, accept_block is set to False and printed.

3. Final Answer:

   False -> Option A

4. Quick Check:

   45 > 50%? No, so False [OK]

Hint: Check if vote is over 50% to accept block [OK]

Common Mistakes:

• Assuming 45 is greater than 50%
• Confusing True/False outputs
• Expecting syntax errors in simple if-else

4. The following code tries to check if a block is accepted using Proof of Stake but has an error:

stake = 30
if stake >= 50
    block_accepted = True
else:
    block_accepted = False
print(block_accepted)

What is the error?

medium

A. Missing colon after if condition

B. Wrong variable name 'stake'

C. Indentation error on else

D. print statement syntax error

Solution

1. Step 1: Check if statement syntax

   The if statement is missing a colon ':' at the end of the condition line.

2. Step 2: Verify other parts

   Variable names, indentation, and print syntax are correct.

3. Final Answer:

   Missing colon after if condition -> Option A

4. Quick Check:

   if statement needs ':' [OK]

Hint: Always put ':' after if conditions [OK]

Common Mistakes:

• Ignoring missing colon errors
• Thinking indentation is wrong
• Assuming variable names cause error

5. You want to design a blockchain that uses Proof of Stake but only allows nodes with at least 100 tokens to vote. Which code snippet correctly filters nodes before voting?

hard

A. valid_nodes = [node for node in nodes if node.tokens < 100]

B. valid_nodes = [node for node in nodes if node.tokens > 1000]

C. valid_nodes = [node for node in nodes if node.tokens == 50]

D. valid_nodes = [node for node in nodes if node.tokens >= 100]

Solution

1. Step 1: Understand the filtering condition

   Nodes must have at least 100 tokens, meaning tokens >= 100.

2. Step 2: Check each option's condition

   valid_nodes = [node for node in nodes if node.tokens >= 100] uses >= 100, matching requirement; others do not.

3. Final Answer:

   valid_nodes = [node for node in nodes if node.tokens >= 100] -> Option D

4. Quick Check:

   At least 100 tokens = tokens >= 100 [OK]

Hint: Use >= 100 to include nodes with 100 tokens [OK]

Common Mistakes:

• Using > 100 excludes nodes with exactly 100 tokens
• Using < or == filters wrong nodes
• Confusing token count conditions