Assertion patterns in Blockchain / Solidity - Mini Project: Build & Apply

Assertion Patterns in Blockchain Smart Contracts

📖 Scenario: You are building a simple smart contract for a blockchain-based voting system. To ensure the contract works correctly, you will use assertion patterns to check important conditions during the voting process.

🎯 Goal: Create a smart contract that stores votes for candidates and uses assertions to verify that votes are valid and the voting process is correct.

📋 What You'll Learn

Create a dictionary to store candidates and their vote counts

Add a variable to track the minimum valid vote count

Use assertions to check that votes are only added to valid candidates and vote counts do not go below zero

Print the final vote counts

💡 Why This Matters

🌍 Real World

Assertions in smart contracts help catch errors early and prevent invalid transactions on the blockchain.

💼 Career

Blockchain developers use assertion patterns to write safer contracts that protect users and assets.

1

DATA SETUP: Create the initial vote counts

Create a dictionary called votes with these exact entries: 'Alice': 0, 'Bob': 0, 'Charlie': 0

Blockchain / Solidity

# Create a dictionary called votes with keys 'Alice', 'Bob', and 'Charlie' all set to 0
# Your code here

Hint

Use curly braces to create a dictionary with the candidate names as keys and 0 as their initial vote counts.

2

CONFIGURATION: Set the minimum valid vote count

Create a variable called min_votes and set it to 0 to represent the minimum valid vote count

Blockchain / Solidity

votes = {'Alice': 0, 'Bob': 0, 'Charlie': 0}
# Create a variable min_votes and set it to 0
# Your code here

Hint

This variable will help us check that votes never go below zero.

3

CORE LOGIC: Use assertions to validate votes

Write a for loop with variables candidate and count to iterate over votes.items(). Inside the loop, use assert to check that candidate is one of 'Alice', 'Bob', or 'Charlie', and that count is greater than or equal to min_votes

Blockchain / Solidity

votes = {'Alice': 0, 'Bob': 0, 'Charlie': 0}
min_votes = 0
# Use a for loop to iterate over votes.items() and assert candidate validity and count >= min_votes
# Your code here

Hint

Assertions help us catch errors early by checking conditions that must always be true.

4

OUTPUT: Display the final vote counts

Write print(votes) to display the dictionary with the vote counts

Blockchain / Solidity

votes = {'Alice': 0, 'Bob': 0, 'Charlie': 0}
min_votes = 0
for candidate, count in votes.items():
    assert candidate in ['Alice', 'Bob', 'Charlie'], "Invalid candidate"
    assert count >= min_votes, "Vote count cannot be negative"
# Print the votes dictionary
# Your code here

Hint

Printing the dictionary shows the current vote counts for each candidate.

Practice

1.

What is the main purpose of an assertion in blockchain smart contract testing?

easy

A. To optimize the contract's gas usage

B. To log information without affecting execution

C. To deploy the contract to the blockchain

D. To check if a condition is true and stop execution if false

Solution

1. Step 1: Understand assertion role

   Assertions verify conditions during execution to ensure correctness.

2. Step 2: Identify assertion effect

   If the condition is false, assertions stop execution and revert changes to prevent errors.

3. Final Answer:

   To check if a condition is true and stop execution if false -> Option D

4. Quick Check:

   Assertions stop execution on false condition [OK]

Hint: Assertions stop code if condition fails, preventing errors [OK]

Common Mistakes:

• Thinking assertions only log info without stopping
• Confusing assertions with deployment steps
• Assuming assertions optimize gas usage

2.

Which of the following is the correct syntax for an assertion in Solidity?

?

easy

A. assert: balance >= amount;

B. assert(balance >= amount);

C. assert(balance < amount);

D. assert(balance = amount);

Solution

1. Step 1: Recall Solidity assertion syntax

   Assertions use the function-like syntax: assert(condition);

2. Step 2: Check condition correctness

   Condition should be a boolean expression, here balance >= amount is valid.

3. Final Answer:

   assert(balance >= amount); -> Option B

4. Quick Check:

   assert(condition) uses parentheses and semicolon [OK]

Hint: Assertions use assert(condition); with parentheses and semicolon [OK]

Common Mistakes:

• Using colon instead of parentheses
• Using assignment (=) instead of comparison (>=)
• Writing incorrect comparison operators

3.

Consider this Solidity code snippet:

uint balance = 100;
uint amount = 150;
assert(balance >= amount);

What will happen when this code runs?

medium

A. Execution continues normally

B. balance is updated to amount

C. Execution stops and reverts due to failed assertion

D. Compilation error due to invalid assertion

Solution

1. Step 1: Evaluate assertion condition

   balance is 100, amount is 150, so balance >= amount is false.

2. Step 2: Understand assertion behavior on false

   Assertion fails, so execution stops and reverts all changes.

3. Final Answer:

   Execution stops and reverts due to failed assertion -> Option C

4. Quick Check:

   False assertion stops execution [OK]

Hint: False assertion stops execution and reverts changes [OK]

Common Mistakes:

• Assuming code continues after failed assertion
• Thinking assertion causes compile error
• Believing balance changes automatically

4.

Identify the error in this Solidity assertion statement:

assert(balance = amount);

medium

A. Using assignment operator instead of comparison

B. Missing semicolon at the end

C. Incorrect function name, should be require()

D. balance and amount are undefined

Solution

1. Step 1: Analyze operator usage

   The single equals sign (=) assigns value, not compares values.

2. Step 2: Correct operator for assertion

   Assertions require comparison operators like == or >= to check conditions.

3. Final Answer:

   Using assignment operator instead of comparison -> Option A

4. Quick Check:

   Use '==' for comparison in assertions [OK]

Hint: Use '==' for comparison, not '=' assignment in assertions [OK]

Common Mistakes:

• Confusing '=' with '==' in conditions
• Thinking require() must replace assert() always
• Ignoring missing semicolon (which is present here)

5.

You want to assert that a user's balance is positive and provide a clear error message if not. Which assertion pattern is best?

?

hard

A. require(balance > 0, "Balance must be positive");

B. assert(balance > 0, "Balance must be positive");

C. assert(balance > 0);

D. if(balance <= 0) revert("Balance must be positive");

Solution

1. Step 1: Understand assertion vs require

   In Solidity, assert is for internal errors without messages; require allows error messages.

2. Step 2: Choose assertion with message

   require(condition, message) is best to check user input and show clear error.

3. Final Answer:

   require(balance > 0, "Balance must be positive"); -> Option A

4. Quick Check:

   Use require() for checks with error messages [OK]

Hint: Use require() to assert with clear error messages [OK]

Common Mistakes:

• Using assert() with message (not supported)
• Ignoring error messages in assertions
• Using if + revert instead of require() unnecessarily