Data types (uint, int, bool, address, string) in Blockchain / Solidity - Deep Dive

Overview - Data types (uint, int, bool, address, string)

What is it?

Data types in blockchain programming define the kind of information a variable can hold. Common types include uint for positive numbers, int for numbers that can be positive or negative, bool for true or false values, address for storing blockchain addresses, and string for text. Each type helps the program understand how to store and use data correctly. This ensures the blockchain code runs safely and predictably.

Why it matters

Without clear data types, blockchain programs would be confused about what kind of data they handle, leading to errors or security risks. For example, mixing numbers with addresses or text could cause wrong transactions or lost funds. Data types protect the blockchain's trustworthiness by making sure data is used exactly as intended.

Where it fits

Before learning data types, you should understand basic programming concepts like variables and values. After mastering data types, you can learn about functions, control flow, and smart contract design to build real blockchain applications.

Mental Model

Core Idea

Data types are labels that tell the blockchain what kind of information each piece of data holds, so it can handle it correctly and safely.

Think of it like...

Think of data types like different boxes for storing things: a box for numbers, a box for yes/no answers, a box for addresses, and a box for words. You put each item in the right box so you can find and use it properly later.

┌─────────────┐
│   Variable  │
├─────────────┤
│ Data Type   │───> uint (positive numbers)
│             │───> int (positive & negative numbers)
│             │───> bool (true/false)
│             │───> address (blockchain addresses)
│             │───> string (text)
└─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Unsigned Integers (uint)

Concept: Introduce uint as a data type for positive whole numbers including zero.

In blockchain, uint stands for unsigned integer. It means the number can only be zero or positive, never negative. For example, uint can hold values like 0, 1, 100, or 1000. This is useful for things like counting tokens or balances, where negative numbers don't make sense.

Result

You can store and use positive numbers safely without worrying about negative values.

Knowing uint prevents errors from negative numbers in places where only positive counts make sense, like money or item quantities.

2

Foundation

Introducing Signed Integers (int)

Concept: Explain int as a data type that can hold both positive and negative whole numbers.

The int type allows numbers to be positive, zero, or negative. For example, int can hold -10, 0, or 25. This is useful when you need to represent values that can go below zero, like debts or temperature changes.

Result

You can represent a wider range of numbers including negatives.

Understanding int lets you handle situations where values can decrease below zero, which uint cannot represent.

3

Intermediate

Boolean Type for True/False

🤔Before reading on: do you think bool can hold more than two values? Commit to yes or no.

Concept: Introduce bool as a data type that holds only true or false values.

Bool stands for boolean and can only be true or false. It is used to represent yes/no, on/off, or any two-choice condition. For example, a bool can track if a user is active (true) or not (false).

Result

You can make decisions in your code based on simple true or false conditions.

Knowing bool helps you control program flow and logic by checking conditions clearly and efficiently.

4

Intermediate

Address Type for Blockchain Accounts

🤔Before reading on: do you think an address is just a string of text? Commit to yes or no.

Concept: Explain address as a special data type that stores blockchain account identifiers.

The address type holds a unique identifier for blockchain accounts or contracts. It looks like a long string of letters and numbers, but it is not just text. It is used to send or receive cryptocurrency and interact with contracts. For example, you store a user's wallet address in this type.

Result

You can safely store and use blockchain addresses to send funds or call contracts.

Understanding address type prevents mixing addresses with regular text, which could cause errors or security issues.

5

Intermediate

String Type for Text Data

Concept: Introduce string as a data type for storing text or words.

String holds sequences of characters like letters, numbers, or symbols. For example, you can store names, messages, or descriptions in a string. Unlike numbers, strings are treated as text and cannot be used for math operations directly.

Result

You can store and display readable text in your blockchain programs.

Knowing string type helps you handle user input, labels, or messages clearly separated from numbers.

6

Advanced

Choosing Correct Data Types for Efficiency

🤔Before reading on: do you think using bigger data types always makes your program safer? Commit to yes or no.

Concept: Explain how picking the right data type size affects blockchain storage and cost.

Blockchain storage costs money, so using the smallest data type that fits your data saves resources. For example, uint8 uses less space than uint256 if your numbers are small. Choosing the right type reduces transaction fees and speeds up execution.

Result

Your smart contracts become cheaper and faster by using efficient data types.

Understanding data size impact helps you write optimized blockchain code that saves money and runs better.

7

Expert

Data Type Safety and Security Implications

🤔Before reading on: do you think mixing data types in blockchain code can cause security risks? Commit to yes or no.

Concept: Explore how incorrect data type use can lead to bugs or vulnerabilities in smart contracts.

Using wrong data types or mixing them carelessly can cause unexpected behavior. For example, treating an address as a string or using int where only uint is safe can open doors for attacks or lost funds. Solidity and other blockchain languages enforce strict typing to prevent these issues, but developers must understand the risks.

Result

You write safer smart contracts by respecting data type rules and avoiding type confusion.

Knowing the security risks tied to data types helps prevent costly bugs and exploits in blockchain applications.

Under the Hood

Each data type in blockchain programming is stored in a specific way in the blockchain's memory and storage. Unsigned integers (uint) use binary bits to represent only positive numbers, while signed integers (int) use one bit for the sign and the rest for the value. Booleans use a single bit to represent true or false. Addresses are fixed-size byte arrays that represent unique blockchain accounts. Strings are stored as sequences of bytes with length information. The blockchain virtual machine enforces these types strictly to ensure data integrity and security.

Why designed this way?

Data types were designed to match the blockchain's need for precise, predictable, and secure data handling. Using fixed sizes and strict typing prevents errors and exploits common in loosely typed systems. The separation between addresses and strings avoids confusion between account identifiers and text. This design balances efficiency, security, and clarity in smart contract development.

┌───────────────┐
│ Blockchain VM │
├───────────────┤
│  Memory Slot  │<── uint (binary positive numbers)
│  Memory Slot  │<── int (binary with sign bit)
│  Memory Slot  │<── bool (1 bit true/false)
│  Memory Slot  │<── address (fixed 20 bytes)
│  Memory Slot  │<── string (length + bytes)
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think uint can hold negative numbers? Commit to yes or no.

Common Belief: Uint can store negative numbers just like int.

Reality: Uint only stores zero and positive numbers; it cannot represent negatives.

Why it matters: Using uint for negative values causes unexpected wrap-around errors, leading to wrong calculations or security flaws.

Quick: Is an address just a string of characters? Commit to yes or no.

Common Belief: An address is just a normal string and can be treated like any text.

Reality: An address is a fixed-size binary value representing a blockchain account, not a general string.

Why it matters: Treating addresses as strings can cause bugs or security issues, like sending funds to wrong places.

Quick: Can bool hold values other than true or false? Commit to yes or no.

Common Belief: Bool can hold multiple values like numbers or strings.

Reality: Bool strictly holds only true or false values.

Why it matters: Misusing bool can cause logic errors and unpredictable contract behavior.

Quick: Does using bigger data types always make your contract safer? Commit to yes or no.

Common Belief: Using larger data types like uint256 everywhere is safer and better.

Reality: Larger data types cost more gas and can be inefficient; choosing the right size is safer and cheaper.

Why it matters: Ignoring data size leads to higher costs and slower contracts, reducing usability.

Expert Zone

1

Addresses in Ethereum are 20 bytes but are often displayed as 40 hexadecimal characters, which can confuse beginners about their actual size.

2

Boolean values in Solidity consume a full 1 byte in storage due to how the EVM handles storage slots, which can impact gas costs when used in arrays or structs.

3

Strings in Solidity are UTF-8 encoded but do not support direct indexing like arrays, requiring careful handling for manipulation.

When NOT to use

Avoid using int when negative values are not logically possible; prefer uint for clarity and safety. Do not use string for storing fixed-size data like addresses; use address type instead. For complex data, consider structs or bytes arrays rather than multiple strings or ints. When performance and gas cost are critical, choose smaller uint sizes or packed structs.

Production Patterns

In real smart contracts, uint256 is commonly used for token balances to match Ethereum's word size, but smaller uint sizes are used for flags or counters to save gas. Addresses are always used for user or contract identifiers, never strings. Booleans control feature toggles or states. Strings are used sparingly due to gas costs, often replaced by bytes or enums.

Connections

Type Systems in Programming Languages

Data types in blockchain are a specialized form of type systems found in all programming languages.

Understanding blockchain data types deepens your grasp of how type systems enforce rules and safety across all coding environments.

Memory Management in Computer Architecture

Data types correspond to how data is stored and accessed in computer memory hardware.

Knowing how data types map to memory helps optimize blockchain contracts for speed and cost.

Cryptographic Hash Functions

Addresses in blockchain are often derived from cryptographic hashes of public keys.

Understanding addresses as hash outputs links data types to cryptography, showing how security and identity are encoded.

Common Pitfalls

#1 Using int where only positive numbers make sense.

Wrong approach:

int balance = -10; // Negative balance allowed incorrectly

Correct approach:

uint balance = 10; // Only positive balance allowed

Root cause:

Confusing when to use signed vs unsigned integers leads to logical errors and potential vulnerabilities.

#2 Storing blockchain addresses as strings.

Wrong approach:

string userAddress = "0x1234..."; // Address stored as text

Correct approach:

address userAddress = 0x1234567890abcdef1234567890abcdef12345678; // Proper address type

Root cause:

Misunderstanding the special nature of addresses causes bugs and security risks.

#3 Assuming bool can hold more than true/false.

Wrong approach:

bool flag = 2; // Invalid boolean value

Correct approach:

bool flag = true; // Valid boolean value

Root cause:

Not knowing bool's strict true/false nature leads to invalid logic.

Key Takeaways

Data types label the kind of data stored so blockchain programs handle information correctly and safely.

Uint holds only zero or positive numbers, while int can hold negative and positive numbers.

Bool stores simple true or false values, essential for decision-making in code.

Address is a special type for blockchain account identifiers, distinct from strings.

Choosing the right data type size improves efficiency, security, and cost in smart contracts.

Practice

1. Which data type should you use in Solidity to store a number that can only be zero or positive?

easy

A. bool

B. uint

C. int

D. address

Solution

1. Step 1: Understand the difference between uint and int

   uint stands for unsigned integer, meaning it can only hold zero or positive numbers. int can hold both positive and negative numbers.

2. Step 2: Identify the correct type for only zero or positive numbers

   Since the question asks for numbers that are zero or positive only, uint is the correct choice.

3. Final Answer:

   uint -> Option B

4. Quick Check:

   Positive numbers = uint [OK]

Hint: Use uint for non-negative numbers only [OK]

Common Mistakes:

• Choosing int for positive-only numbers
• Confusing bool with numeric types
• Using address for numbers

2. Which of the following is the correct way to declare a boolean variable named isActive in Solidity?

easy

A. bool isActive = 0;

B. bool isActive = 1;

C. bool isActive = "true";

D. bool isActive = true;

Solution

1. Step 1: Recall the correct boolean values in Solidity

   Boolean variables can only be assigned true or false, not numbers or strings.

2. Step 2: Check each option for correct boolean assignment

   bool isActive = true; assigns true correctly. Options B and D use numbers, and C uses a string, which are invalid for bool.

3. Final Answer:

   bool isActive = true; -> Option D

4. Quick Check:

   Boolean = true or false [OK]

Hint: Assign true or false to bool variables [OK]

Common Mistakes:

• Using 1 or 0 instead of true/false
• Assigning strings like "true"
• Missing semicolon at the end

3. What will be the output of this Solidity code snippet?

int x = -5;
uint y = 10;
bool flag = (x < 0);
string memory text = "Hello";
address addr = 0x1234567890123456789012345678901234567890;

// Output values
x
flag
text
addr

medium

A. Compilation error due to address format

B. 5, false, Hello, 0x1234567890123456789012345678901234567890

C. -5, true, Hello, 0x1234567890123456789012345678901234567890

D. -5, false, "Hello", 0x0

Solution

1. Step 1: Analyze each variable's value

   x is -5 (signed int), flag is true because x < 0, text is "Hello", and addr is a valid address.

2. Step 2: Confirm output matches variable values

   -5, true, Hello, 0x1234567890123456789012345678901234567890 correctly lists all values as expected. 5, false, Hello, 0x1234567890123456789012345678901234567890 incorrectly changes x and flag. -5, false, "Hello", 0x0 has wrong flag and addr. Compilation error due to address format is wrong because the address format is valid.

3. Final Answer:

   -5, true, Hello, 0x1234567890123456789012345678901234567890 -> Option C

4. Quick Check:

   Variable values printed as is [OK]

Hint: Check variable types and values carefully [OK]

Common Mistakes:

• Assuming uint can hold negative values
• Confusing string quotes in output
• Thinking address format is invalid

4. Identify the error in this Solidity variable declaration:

address myAddress = "0xAbC1234567890";

medium

A. Address must be assigned without quotes

B. Address must be declared as string

C. Address cannot start with 0x

D. Address must be declared as bool

Solution

1. Step 1: Understand address assignment rules

   In Solidity, addresses are assigned as hexadecimal literals without quotes, not as strings.

2. Step 2: Identify the error in the code

   The code uses quotes around the address, making it a string, which is invalid for address type.

3. Final Answer:

   Address must be assigned without quotes -> Option A

4. Quick Check:

   Address literals have no quotes [OK]

Hint: Assign addresses without quotes to avoid errors [OK]

Common Mistakes:

• Using quotes around addresses
• Declaring address as string
• Removing 0x prefix from address

5. You want to store user information in a Solidity contract with these fields: user ID (positive number), username (text), active status (true/false), and wallet address. Which data types should you use for these fields?

hard

A. uint for user ID, string for username, bool for active status, address for wallet

B. int for user ID, string for username, uint for active status, address for wallet

C. uint for user ID, address for username, bool for active status, string for wallet

D. string for user ID, string for username, bool for active status, address for wallet

Solution

1. Step 1: Match each field to the correct data type

   User ID is a positive number, so uint fits. Username is text, so string. Active status is true/false, so bool. Wallet address is a blockchain address, so address.

2. Step 2: Verify options against these matches

   uint for user ID, string for username, bool for active status, address for wallet matches all fields correctly. Other options mix types incorrectly, like using int for user ID or swapping string and address.

3. Final Answer:

   uint for user ID, string for username, bool for active status, address for wallet -> Option A

4. Quick Check:

   Match field types carefully [OK]

Hint: Match data types to field meaning exactly [OK]

Common Mistakes:

• Using int for positive-only IDs
• Confusing string and address
• Using uint for boolean values