Why security prevents financial loss in Blockchain / Solidity - See It in Action

Why Security Prevents Financial Loss in Blockchain

📖 Scenario: Imagine you are building a simple blockchain system that keeps track of transactions. Each transaction has a sender, receiver, and amount. To keep the system safe, you want to check if a transaction is valid before adding it to the blockchain. Invalid transactions could cause financial loss.

🎯 Goal: You will create a small program that stores transactions, sets a minimum security threshold, filters out invalid transactions, and then shows only the safe transactions. This teaches how security checks help prevent financial loss.

📋 What You'll Learn

Create a dictionary called transactions with exact entries for senders, receivers, and amounts

Create a variable called min_amount to set the minimum allowed transaction amount

Use a dictionary comprehension to create a new dictionary secure_transactions that only includes transactions with amounts greater than or equal to min_amount

Print the secure_transactions dictionary to show the filtered safe transactions

💡 Why This Matters

🌍 Real World

In real blockchain systems, security checks prevent fraudulent or invalid transactions that could cause financial loss.

💼 Career

Understanding how to filter and validate data is essential for blockchain developers and security engineers to protect assets.

1

DATA SETUP: Create the transactions dictionary

Create a dictionary called transactions with these exact entries: "tx1": {"sender": "Alice", "receiver": "Bob", "amount": 50}, "tx2": {"sender": "Charlie", "receiver": "Dave", "amount": 20}, "tx3": {"sender": "Eve", "receiver": "Frank", "amount": 5}

Blockchain / Solidity

# Create the transactions dictionary with exact entries
# Your code here

Hint

Use curly braces to create the dictionary. Each key is a string like "tx1" and each value is another dictionary with keys "sender", "receiver", and "amount".

2

CONFIGURATION: Set the minimum allowed transaction amount

Create a variable called min_amount and set it to 10 to represent the minimum secure transaction amount

Blockchain / Solidity

transactions = {
    "tx1": {"sender": "Alice", "receiver": "Bob", "amount": 50},
    "tx2": {"sender": "Charlie", "receiver": "Dave", "amount": 20},
    "tx3": {"sender": "Eve", "receiver": "Frank", "amount": 5}
}
# Set the minimum allowed transaction amount
# Your code here

Hint

Just create a variable named min_amount and assign the number 10 to it.

3

CORE LOGIC: Filter transactions using dictionary comprehension

Use a dictionary comprehension to create a new dictionary called secure_transactions that includes only those transactions from transactions where the amount is greater than or equal to min_amount

Blockchain / Solidity

transactions = {
    "tx1": {"sender": "Alice", "receiver": "Bob", "amount": 50},
    "tx2": {"sender": "Charlie", "receiver": "Dave", "amount": 20},
    "tx3": {"sender": "Eve", "receiver": "Frank", "amount": 5}
}

min_amount = 10
# Use dictionary comprehension to filter transactions
# Your code here

Hint

Use {key: value for key, value in transactions.items() if value["amount"] >= min_amount} to filter.

4

OUTPUT: Print the secure transactions

Write a print statement to display the secure_transactions dictionary

Blockchain / Solidity

transactions = {
    "tx1": {"sender": "Alice", "receiver": "Bob", "amount": 50},
    "tx2": {"sender": "Charlie", "receiver": "Dave", "amount": 20},
    "tx3": {"sender": "Eve", "receiver": "Frank", "amount": 5}
}

min_amount = 10

secure_transactions = {tx_id: details for tx_id, details in transactions.items() if details["amount"] >= min_amount}
# Print the secure_transactions dictionary
# Your code here

Hint

Use print(secure_transactions) to show the filtered transactions.

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