Integer overflow and underflow in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Integer overflow and underflow

Start with integer value

↓

Perform arithmetic operation

↓

Check if result > max value?

Yes→Overflow occurs: wraps to min value

↓

Result is min value

↓

Check if result < min value?

Yes→Underflow occurs: wraps to max value

↓

Result is max value

↓

Result is within range

↓

Use result

↓

End

Start with an integer, do math, then check if it goes beyond max or min limits. If yes, overflow or underflow happens, wrapping the value around.

Execution Sample

Blockchain / Solidity

uint8 x = 255;
x = x + 1;
// x wraps to 0 due to overflow

Add 1 to the max value of an 8-bit unsigned integer, causing overflow and wrapping to 0.

Execution Table

Step	Variable x	Operation	Result	Overflow/Underflow
1	255	Initial value	255	No
2	255 + 1	Add 1	0	Overflow: wraps to 0
3	0	Final value	0	No

💡 After adding 1 to 255, overflow occurs and value wraps to 0, which is within range.

Variable Tracker

Variable	Start	After Step 2	Final
x	255	0	0

Key Moments - 2 Insights

Why does adding 1 to 255 result in 0 instead of 256?

Because the variable is an 8-bit unsigned integer with max 255, adding 1 causes overflow and wraps the value back to 0, as shown in execution_table step 2.

What happens if we subtract 1 from 0 in an unsigned 8-bit integer?

It causes underflow, wrapping the value to 255, the max value. This is similar to overflow but in the opposite direction.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after adding 1 to 255?

A 0

B 256

C 255

D 1

💡 Hint

Check execution_table row 2 under 'Result' column.

At which step does overflow occur according to the execution table?

A Step 1

B Step 2

C Step 3

D No overflow occurs

💡 Hint

Look at the 'Overflow/Underflow' column in execution_table.

If x was a signed 8-bit integer with max 127, what would happen if x = 127 and we add 1?

A Value becomes 128 without issue

B Overflow occurs and value wraps to -128

C Underflow occurs and value wraps to 127

D Program throws an error

💡 Hint

Signed 8-bit integers overflow wraps from max positive to min negative, similar to unsigned wrapping shown in variable_tracker.

Concept Snapshot

Integer overflow and underflow happen when a number goes beyond its storage limits.
Unsigned integers wrap from max to min on overflow, and min to max on underflow.
Example: uint8 max is 255; adding 1 wraps to 0.
Signed integers wrap between positive max and negative min.
Always check for overflow/underflow in blockchain to avoid bugs.

Full Transcript

Integer overflow and underflow occur when a number exceeds its allowed range. For example, an 8-bit unsigned integer can hold values from 0 to 255. Adding 1 to 255 causes overflow, wrapping the value back to 0. Similarly, subtracting 1 from 0 causes underflow, wrapping to 255. This wrapping behavior is important in blockchain programming because it can cause unexpected bugs or vulnerabilities. The execution table shows step-by-step how the value changes and when overflow happens. Understanding this helps prevent errors in smart contracts and other blockchain code.

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