Why security prevents financial loss in Blockchain / Solidity - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does blockchain security reduce financial loss?

Imagine a blockchain network where transactions are recorded. Why does strong security in this network help prevent financial loss?

A Because it makes transactions slower, so hackers get tired and give up.

B Because it hides all transactions so no one can see where money goes.

C Because it stops unauthorized changes to transaction records, ensuring funds are safe.

D Because it allows anyone to change records freely, increasing transparency.

💡 Hint

Think about what happens if someone can change transaction records without permission.

Strong security prevents unauthorized changes to transaction data. This keeps funds safe by ensuring only valid transactions happen.

❓ Predict Output

intermediate

What is the output of this smart contract balance check?

Given this simplified smart contract code snippet, what will be the output after running it?

Blockchain / Solidity

balances = {'Alice': 100, 'Bob': 50}

# Alice tries to send 30 to Bob
amount = 30
sender = 'Alice'
receiver = 'Bob'

if balances.get(sender, 0) >= amount:
    balances[sender] -= amount
    balances[receiver] += amount
    print(f"Transfer successful: {sender} -> {receiver} : {amount}")
else:
    print("Transfer failed: insufficient funds")

A KeyError: 'Alice'

B Transfer failed: insufficient funds

C Transfer successful: Bob -> Alice : 30

D Transfer successful: Alice -> Bob : 30

💡 Hint

Check if Alice has enough balance before sending.

Alice has 100, which is enough to send 30 to Bob. So the transfer succeeds and prints the success message.

🔧 Debug

advanced

Identify the error causing financial loss in this transaction code

Look at this code that handles a transaction. Which option correctly identifies the error that could cause financial loss?

Blockchain / Solidity

def transfer_funds(balances, sender, receiver, amount):
    if balances[sender] > amount:
        balances[sender] -= amount
        balances[receiver] += amount
        return "Transfer complete"
    else:
        return "Insufficient funds"

A The condition should be >= instead of > to allow exact balance transfers.

B The function should add amount to sender instead of subtracting.

C The balances dictionary keys are missing quotes causing a syntax error.

D The function returns a string instead of updating balances.

💡 Hint

Think about what happens if sender tries to send all their money.

The condition uses > which blocks transfers equal to the sender's full balance. This can cause confusion or loss of funds if exact transfers are needed.

📝 Syntax

advanced

What error does this blockchain transaction code raise?

What error will this code produce when executed?

Blockchain / Solidity

transactions = [{'from': 'Alice', 'to': 'Bob', 'amount': 50}]

for tx in transactions:
    print(f"{tx['from']} sends {tx['amount']} to {tx['to']}")

A SyntaxError due to missing colon after for loop

B KeyError because 'from' is a reserved word

C TypeError because transactions is not iterable

D No error, prints the transaction details

💡 Hint

Check the for loop syntax carefully.

The for loop is missing a colon at the end of the line, causing a SyntaxError.

🚀 Application

expert

How many unique transactions are recorded after this code runs?

Consider this code that records transactions in a blockchain ledger. How many unique transactions will the ledger contain after execution?

Blockchain / Solidity

ledger = set()

transactions = [
    ('Alice', 'Bob', 20),
    ('Bob', 'Charlie', 15),
    ('Alice', 'Bob', 20),
    ('Charlie', 'Alice', 5)
]

for tx in transactions:
    ledger.add(tx)

print(len(ledger))

A 4

B 3

C 2

D 1

💡 Hint

Sets do not allow duplicate entries. Count unique tuples.

The transaction ('Alice', 'Bob', 20) appears twice but is stored once in the set. So total unique transactions are 3.