Integer overflow and underflow in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to prevent integer overflow by using a safe addition function.

Blockchain / Solidity

function safeAdd(uint8 a, uint8 b) public pure returns (uint8) {
    uint8 c = a + [1];
    require(c >= a, "Overflow detected");
    return c;
}

Drag options to blanks, or click blank then click option'

A1

Ba

Cb

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable name in the addition.

Adding a constant instead of the variable.

The function adds two unsigned 8-bit integers. To check overflow, it adds b to a and verifies the result is not smaller than a.

2fill in blank

medium

Complete the code to check for underflow before subtraction.

Blockchain / Solidity

function safeSub(uint8 a, uint8 b) public pure returns (uint8) {
    require(a [1] b, "Underflow detected");
    return a - b;
}

Drag options to blanks, or click blank then click option'

A>=

B<

C==

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>=' causing incorrect underflow checks.

Using '==' which is too strict.

Before subtracting, the code checks that a is greater than or equal to b to avoid underflow.

3fill in blank

hard

Fix the error in the code that causes overflow when multiplying two uint8 numbers.

Blockchain / Solidity

function safeMul(uint8 a, uint8 b) public pure returns (uint8) {
    uint8 c = a * [1];
    require(b == 0 || c / b == a, "Overflow detected");
    return c;
}

Drag options to blanks, or click blank then click option'

A0

Ba

C1

Db

Attempts:

3 left

💡 Hint

Common Mistakes

Multiplying a by itself instead of b.

Using a constant instead of the variable.

The multiplication must be between a and b. The check ensures no overflow happened.

4fill in blank

hard

Fill both blanks to create a safe division function that prevents division by zero.

Blockchain / Solidity

function safeDiv(uint8 a, uint8 b) public pure returns (uint8) {
    require(b [1] 0, "Division by zero");
    return a [2] b;
}

Drag options to blanks, or click blank then click option'

A!=

B/

C==

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if b equals zero instead of not equals.

Using multiplication instead of division.

The function checks that b is not zero before dividing a by b.

5fill in blank

hard

Fill all three blanks to create a safe modulo function that prevents modulo by zero.

Blockchain / Solidity

function safeMod(uint8 a, uint8 b) public pure returns (uint8) {
    require(b [1] 0, "Modulo by zero");
    uint8 c = a [2] b;
    return c [3] b;
}

Drag options to blanks, or click blank then click option'

A!=

B%

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or subtraction instead of modulo.

Not checking for zero divisor.

The function checks that b is not zero, then calculates a % b and returns the result.

Practice

1. What happens in blockchain when an unsigned integer variable exceeds its maximum value?

easy

A. It wraps around to zero (integer overflow).

B. It throws an error automatically.

C. It becomes negative.

D. It stays at the maximum value.

Solution

1. Step 1: Understand unsigned integer limits

   Unsigned integers start at 0 and go up to a max value (like 2^256-1 in Solidity).

2. Step 2: What happens when max is exceeded?

   When the value goes above max, it wraps around to 0, causing integer overflow.

3. Final Answer:

   It wraps around to zero (integer overflow). -> Option A

4. Quick Check:

   Unsigned integer overflow = wrap to zero [OK]

Hint: Unsigned integers wrap to zero on overflow [OK]

Common Mistakes:

• Thinking overflow throws an error automatically
• Assuming value becomes negative
• Believing value stays at max

2. Which of the following Solidity code snippets correctly prevents integer underflow when subtracting 1 from a uint variable balance?

easy

A. balance -= 1; require(balance >= 0);

B. balance = balance - 1;

C. if (balance > 0) { balance -= 1; }

D. balance = balance + 1;

Solution

1. Step 1: Identify safe subtraction

   To avoid underflow, subtract only if balance is greater than zero.

2. Step 2: Check each option

   if (balance > 0) { balance -= 1; } checks balance > 0 before subtracting, preventing underflow. The other options either subtract without checking first (allowing underflow) or add instead of subtracting.

3. Final Answer:

   if (balance > 0) { balance -= 1; } -> Option C

4. Quick Check:

   Check before subtracting prevents underflow [OK]

Hint: Check value > 0 before subtracting to avoid underflow [OK]

Common Mistakes:

• Not checking before subtracting
• Using require after subtraction (too late)
• Adding instead of subtracting

3. Consider this Solidity code snippet:

uint8 x = 255;
x += 1;

What is the value of x after execution?

medium

A. 0

B. 1

C. 255

D. 256

Solution

1. Step 1: Understand uint8 max value

   uint8 can hold values from 0 to 255. 255 is the max.

2. Step 2: Add 1 to max value

   Adding 1 causes overflow, wrapping value back to 0.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   uint8 overflow wraps to 0 [OK]

Hint: uint8 max is 255; adding 1 wraps to 0 [OK]

Common Mistakes:

• Expecting 256 (out of range)
• Expecting value to stay at 255
• Confusing with signed integers

4. This Solidity function tries to subtract 1 from count. What is the bug?

function decrement(uint count) public pure returns (uint) {
    count -= 1;
    return count;
}

medium

A. No bug; works fine.

B. Underflow if count is 0, wrapping to max uint.

C. Syntax error due to missing semicolon.

D. Returns negative number which is invalid.

Solution

1. Step 1: Analyze subtraction without check

   The function subtracts 1 from count without checking if count is zero.

2. Step 2: Understand underflow risk

   If count is 0, subtracting 1 causes underflow, wrapping to max uint value.

3. Final Answer:

   Underflow if count is 0, wrapping to max uint. -> Option B

4. Quick Check:

   Subtracting 1 from 0 causes underflow [OK]

Hint: Check before subtracting to avoid underflow [OK]

Common Mistakes:

• Assuming no bug without checks
• Thinking Solidity throws error automatically
• Confusing underflow with negative return

5. You have a smart contract token balance stored as uint256. You want to safely add tokens without overflow. Which approach is best?

hard

A. Convert to int256 and add.

B. Use unchecked addition: balance += amount;

C. Subtract amount first, then add balance.

D. Use SafeMath library's add function to check overflow.

Solution

1. Step 1: Understand overflow risk in addition

   Adding tokens can overflow uint256 max value, causing wraparound bugs.

2. Step 2: Use SafeMath library

   SafeMath's add function checks for overflow and reverts if it happens, preventing bugs.

3. Step 3: Evaluate other options

   Unchecked addition risks overflow. Subtracting first or converting to int256 does not prevent overflow safely.

4. Final Answer:

   Use SafeMath library's add function to check overflow. -> Option D

5. Quick Check:

   SafeMath add prevents overflow [OK]

Hint: Use SafeMath add to prevent overflow safely [OK]

Common Mistakes:

• Using unchecked addition risking overflow
• Trying to subtract before adding
• Converting to signed int without checks