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.

Practice

1. Why is security important in blockchain to prevent financial loss?

easy

A. It increases the size of the blockchain.

B. It stops unauthorized people from accessing your digital money.

C. It makes transactions slower.

D. It allows anyone to change transaction history.

Solution

1. Step 1: Understand unauthorized access risk

   Unauthorized access means someone can take your money without permission.

2. Step 2: Recognize security's role

   Security prevents unauthorized access, protecting your digital assets.

3. Final Answer:

   It stops unauthorized people from accessing your digital money. -> Option B

4. Quick Check:

   Security prevents unauthorized access = C [OK]

Hint: Security blocks unauthorized access to your money [OK]

Common Mistakes:

• Thinking security slows down transactions
• Believing blockchain size affects security
• Assuming anyone can change history

2. Which of the following is the correct way to verify a transaction in blockchain code?

easy

A. if transaction.verify(): process()

B. if verify(transaction): process()

C. verify if transaction process()

D. process() if verify transaction

Solution

1. Step 1: Identify correct method call syntax

   In modern blockchain code, transactions have a verify() method called with dot notation.

2. Step 2: Check each option's syntax

   if transaction.verify(): process() uses correct method call: transaction.verify(). Others have syntax errors.

3. Final Answer:

   if transaction.verify(): process() -> Option A

4. Quick Check:

   Method call syntax = B [OK]

Hint: Use dot notation for method calls like transaction.verify() [OK]

Common Mistakes:

• Writing method calls without parentheses
• Using wrong order of keywords
• Missing dot between object and method

3. What will the following code output if the transaction is invalid?

transaction = {'valid': False}
def verify(tx):
    return tx['valid']

if verify(transaction):
    print('Transaction accepted')
else:
    print('Transaction rejected')

medium

A. Error: KeyError

B. Transaction accepted

C. Transaction rejected

D. No output

Solution

1. Step 1: Check transaction validity

   The transaction dictionary has 'valid' set to False.

2. Step 2: Evaluate verify function and if condition

   verify(transaction) returns False, so else branch runs printing 'Transaction rejected'.

3. Final Answer:

   Transaction rejected -> Option C

4. Quick Check:

   False validity means rejection = A [OK]

Hint: False validity leads to rejection message [OK]

Common Mistakes:

• Assuming True by default
• Confusing dictionary keys
• Expecting no output on False

4. Find the error in this blockchain transaction verification code:

def verify(tx):
    if tx['amount'] > 0
        return True
    else:
        return False

medium

A. Incorrect function name

B. Wrong comparison operator

C. Missing return statement

D. Missing colon after if condition

Solution

1. Step 1: Check syntax of if statement

   The if line lacks a colon at the end, which is required in Python syntax.

2. Step 2: Verify other parts

   Comparison operator and return statements are correct; function name is valid.

3. Final Answer:

   Missing colon after if condition -> Option D

4. Quick Check:

   Python if needs colon = A [OK]

Hint: Always put colon after if condition in Python [OK]

Common Mistakes:

• Forgetting colon after if
• Changing comparison operator unnecessarily
• Omitting return statements

5. You want to prevent double spending in your blockchain app. Which security practice helps most to avoid financial loss?

hard

A. Verify each transaction is unique and not spent before

B. Store transactions only on one computer

C. Ignore transaction verification for speed

D. Allow multiple transactions with same ID

Solution

1. Step 1: Understand double spending risk

   Double spending means using the same money twice, causing financial loss.

2. Step 2: Identify security practice to prevent it

   Verifying each transaction is unique and not spent before stops double spending.

3. Final Answer:

   Verify each transaction is unique and not spent before -> Option A

4. Quick Check:

   Unique transaction verification prevents loss = D [OK]

Hint: Check transaction uniqueness to stop double spending [OK]

Common Mistakes:

• Allowing duplicate transaction IDs
• Skipping verification for speed
• Relying on single computer storage