Smart contract state variables

Solidity & DeFi journey

Token world

Solidity basics

0/22

Meeting

Hello, Blockchain!

Smart contract structure

Smart contract state variables

Functions and Interaction

Data Operations — Basics

Numeric and Boolean Data Types

Strings, Bytes and Addresses

Local Variables and State Variables

Constants and Immutable Variables

Functions with Multiple Return Values

Variable Visibility Modifiers

Function Visibility and Behavior Modifiers

Advanced Operations and Security

Remix IDE — Platform Introduction

Remix IDE — Advanced Features

Basic Error Handling

Advanced Error Handling

Custom Modifiers

Arrays - Basics of Ordered Data

Mappings - Associative Data Structures

Structs and Enums - Data Grouping

Blockchain basics

0/0

Basic cryptography

0/0

Скидки на «Starter» и «Pro» до

Выбрать тариф

State variables — smart contract memoryAlex starts with contract state variables:
Okay, a variable is like a box with a name. Today one thing is in it, tomorrow another. The most important thing — the new value of a state variable is saved if it was changed in a function. Blockchain can store information!
Variables
﻿
TermsState variable — a variable that is stored in the blockchain and accessible to all contract functions for reading or modification. Declared in the contract body. State variables can be modified inside smart contract functions. They form the contract's memory and persist between function calls. Changing a state variable in a function increases the cost of calling that function. For brevity, we'll refer to state variables simply as variables.
Variable visibility modifier — a keyword that defines who can read the variable – the current contract, inheriting contract, user with a wallet, or external contract. Examples of visibility modifiers are public, private, or internal.
State variable declarationVariable declaration starts with a data type that defines what type of values can be stored in this variable. Then comes the variable name. Between the type and name, a visibility modifier can be placed. The visibility modifier determines who can read this variable.
Solidity
contract MyContract {
    ...
﻿
    data_type variable_name;
    data_type public variable_name;
    data_type private variable_name;
    data_type internal variable_name;
﻿
    ...
}
Variable data typesAlex understands an important principle:
— "Every variable in Solidity must have its data type! It's like a label on a box — it tells what exactly can be put in this box."
Data type defines:
What values the variable can store
How much memory it occupies
What operations can be performed with it
Basic data types in Solidity:
uint256 — for positive integers (0, 1, 2, 100, 1000000...)
int256 — for integers including negative (-100, -1, 0, 1, 100...)
bool — for boolean values (true or false)
string or string memory — for text ("Hello", "Alex", "My contract"...)
address — for wallet and smart contract addresses
bytes or bytes memory — for binary data
— "Without specifying a type, Solidity won't understand what I want to store in the variable. It's like saying 'give me a box' without explaining what it's for — for shoes, books, or groceries!"
Visibility modifiers for variablesAlex wonders:
— "Interesting, who can actually see my variables? Can any user look at what's stored in my contract? Or are there ways to hide information?"
public – the variable can be read by everyone. A getter function is automatically created, allowing everyone to read the variable value from outside the contract. For example, for uint256 public counter a function function counter() public view returns (uint256) will be created, which any contract or user can use to read the counter variable value.
private – the variable is accessible for reading only within this contract, even inheriting contracts cannot read it
internal – the variable is accessible for reading within the contract and its inheritors (default for variables)
By default, variables are declared as internal.
Important: The public modifier only allows reading the variable from outside the contract, but doesn't affect the ability to modify it. Only functions inside the contract can modify the variable. To make a variable modifiable from outside, you need to create a special function for that.
Also important: The internal or private modifiers don't allow hiding or encrypting information! They only restrict the ability of other smart contracts to access it. In blockchain, all data is public, so state variables are not suitable for storing secret information.
Alex decided to understand variables better and created a smart contract to experiment with variables. He tries a simple example:
Solidity
﻿
contract SimpleStorage {
    // This is a variable named "message" that stores text.
    // Accessible only within the contract
    string message;
﻿
    // This is a variable named "number" that stores a number.
    // Accessible only within the contract and its child contracts
    uint256 number;
﻿
    // This is a variable named "publicNumber" that stores a number.
    // Accessible to everyone
    uint256 public publicNumber;
﻿
    // This is a variable named "privateBool" that stores a boolean value – true or false.
    // Accessible only within the contract
    bool private privateBool;
﻿
    // This is a variable named "internalAddress" that stores an address.
    // Accessible only within the contract and its child contracts
    address internal internalAddress;
}
﻿
One variable stores text, another — a number. Alex understands: variables are different. There are string variables — for text. There are numeric variables — for mathematical calculations. There are boolean values — true or false. There are addresses — for storing data about owners and users.
Default variable initializationAlex notices an interesting feature:
— "What if I declare a variable but don't assign it a value? What will be stored in it?"
He studies the documentation and learns an important rule: in Solidity all variables are automatically initialized with default values.
Each data type has a default value that will be stored in the variable if no value is assigned to it.
Default values for different typesSolidity
contract DefaultValues {
    // Numeric types are initialized to zero
    uint256 public number;           // 0
    int256 public signedNumber;      // 0
    uint8 public smallNumber;        // 0
﻿
    // Boolean type is initialized to false
    bool public flag;                // false
﻿
    // Address is initialized to zero address
    address public userAddress;      // 0x0000000000000000000000000000000000000000
﻿
    // Strings and bytes are initialized empty
    string public message;           // ""
    bytes public data;               // 0x (empty byte array)
﻿
    // Arrays are initialized empty
    uint256[] public numbers;        // []
    address[] public users;          // []
}
— "So, in Solidity there are no uninitialized variables! This is safe — no risk of using 'garbage' data."
Explicit initializationAlex also learns that you can explicitly initialize a variable — that is, assign it an initial value. This can be done in two ways:
Initialization at declarationThe simplest way — assign a value to the variable immediately when declaring it:
Solidity
contract DirectInitialization {
    // Initialization immediately at declaration
    uint256 public counter = 100;              // Counter starts at 100
    string public greeting = "Hello, world!";   // Welcome message
    bool public isActive = true;               // Contract is active by default
    address public admin = 0x1234567890AbcdEF1234567890AbcdEF12345678;  // Fixed admin address
﻿
    // Can use mathematical expressions
    uint256 public maxUsers = 1000 * 100;      // Maximum 100,000 users
    uint256 public fee = 5;                    // 5% fee
}
This method is suitable for values that are:
Known in advance at the code writing stage
The same for all contract instances
Don't depend on external conditions
Initialization in constructorAlex learns about constructor — a special function that executes once when creating a contract.
— "Constructor is like a ship launching ceremony. It happens only once, when the contract appears in the blockchain. After that, the constructor is never called again."
What is a constructor?Constructor — is a special function that:
Executes automatically when deploying the contract
Can accept parameters from the contract creator
Is used to configure the initial state
Is called only once in the contract's lifetime
Solidity
contract ConstructorInitialization {
    // Variables that will be initialized in the constructor
    address public owner;
    uint256 public creationTime;
    uint256 public initialBalance;
    string public contractName;
﻿
    // Constructor executes when creating the contract
    constructor(string memory _name, uint256 _balance) {
        owner = msg.sender;              // Owner — the one who created the contract
        creationTime = block.timestamp;  // Contract creation time
        initialBalance = _balance;       // Initial balance passed as parameter
        contractName = _name;            // Contract name passed as parameter
    }
}
This method is suitable for values that:
Depend on contract creation conditions (who created, when created)
Are passed as parameters during deployment
Are calculated based on blockchain state at creation time
Choosing initialization methodAlex derives rules for choosing between different initialization methods:
1. Initialization at declarationUse when values are known in advance and fixed:
Solidity
contract TokenSettings {
    uint256 public maxSupply = 1000000;        // Maximum number of tokens
    string public name = "MyToken";            // Token name
    uint8 public decimals = 18;                // Number of decimal places
    uint256 public transferFee = 5;            // Transfer fee (5%)
}
2. Initialization in constructorUse when values depend on creation conditions:
Solidity
contract DynamicContract {
    address public owner;
    uint256 public creationTime;
    uint256 public initialSupply;
    string public customName;
﻿
    constructor(string memory _name, uint256 _supply) {
        owner = msg.sender;           // Depends on who creates the contract
        creationTime = block.timestamp; // Depends on creation time
        initialSupply = _supply;      // Passed as parameter
        customName = _name;           // Configured at creation
    }
}
3. Default valuesUse when zero value is suitable:
Solidity
contract UserStats {
    uint256 public score;        // Automatically 0 — new users start from zero
    bool public isVerified;      // Automatically false — users are not verified
    uint256 public lastLogin;    // Automatically 0 — haven't logged in yet
}
— "Now I understand! Solidity takes care of safety itself — no random values. And I can choose the most suitable method for each variable."
Complex practical exampleAlex decides to create a gaming platform contract that demonstrates all initialization methods:
Solidity
contract GamePlatform {
    // === 1. INITIALIZATION AT DECLARATION ===
    // Used for fixed game settings
    string public constant PLATFORM_NAME = "CryptoGameHub";  // Constant
    uint256 public maxPlayers = 1000;                        // Maximum players
    uint256 public entryFee = 0.01 ether;                   // Entry cost
    bool public isMaintenanceMode = false;                   // Maintenance mode disabled
﻿
    // === 2. DEFAULT VALUES ===
    // Used when zero values are suitable
    uint256 public totalGamesPlayed;     // 0 - no games yet
    uint256 public totalPrizePool;       // 0 - prize pool empty
    bool public seasonStarted;           // false - season not started
﻿
    // === 3. INITIALIZATION IN CONSTRUCTOR ===
    // Used for dynamic values
    address public owner;                // Platform owner
    uint256 public platformLaunchTime;   // Platform launch time
    uint256 public seasonNumber;         // Current season number
    string public welcomeMessage;        // Personalized welcome
﻿
    constructor(uint256 _seasonNumber, string memory _message) {
        // Values depending on contract creator
        owner = msg.sender;                     // The one who deployed the contract
        platformLaunchTime = block.timestamp;   // Current blockchain time
﻿
        // Values passed at creation
        seasonNumber = _seasonNumber;           // Season number set at creation
        welcomeMessage = _message;              // Message is configured
    }
}
— "Excellent! Now I see how different initialization methods work together. Each has its purpose and helps make code more understandable and efficient."
Practical assignment on variable initializationAlex studied the theory of variable initialization and decided to apply the knowledge in practice:
— "Now I know how to properly declare variables! Let me try to create a contract for storing information about a defi platform."
But when he started writing code, he made several mistakes. Help Alex fix the problems with variable initialization.
Практические задания
Загрузка...
Additional materialsOfficial documentation﻿Solidity by example – Variables﻿
﻿Solidity Documentation - Variables — detailed description of state variables
﻿Solidity Documentation - Constants — guide on constants and immutable variables

Скидки на «Starter» и «Pro» до

Выбрать тариф

State variables — smart contract memoryAlex starts with contract state variables:
Okay, a variable is like a box with a name. Today one thing is in it, tomorrow another. The most important thing — the new value of a state variable is saved if it was changed in a function. Blockchain can store information!
Variables
﻿
TermsState variable — a variable that is stored in the blockchain and accessible to all contract functions for reading or modification. Declared in the contract body. State variables can be modified inside smart contract functions. They form the contract's memory and persist between function calls. Changing a state variable in a function increases the cost of calling that function. For brevity, we'll refer to state variables simply as variables.
Variable visibility modifier — a keyword that defines who can read the variable – the current contract, inheriting contract, user with a wallet, or external contract. Examples of visibility modifiers are public, private, or internal.
State variable declarationVariable declaration starts with a data type that defines what type of values can be stored in this variable. Then comes the variable name. Between the type and name, a visibility modifier can be placed. The visibility modifier determines who can read this variable.
Solidity
contract MyContract {
    ...
﻿
    data_type variable_name;
    data_type public variable_name;
    data_type private variable_name;
    data_type internal variable_name;
﻿
    ...
}
Variable data typesAlex understands an important principle:
— "Every variable in Solidity must have its data type! It's like a label on a box — it tells what exactly can be put in this box."
Data type defines:
What values the variable can store
How much memory it occupies
What operations can be performed with it
Basic data types in Solidity:
uint256 — for positive integers (0, 1, 2, 100, 1000000...)
int256 — for integers including negative (-100, -1, 0, 1, 100...)
bool — for boolean values (true or false)
string or string memory — for text ("Hello", "Alex", "My contract"...)
address — for wallet and smart contract addresses
bytes or bytes memory — for binary data
— "Without specifying a type, Solidity won't understand what I want to store in the variable. It's like saying 'give me a box' without explaining what it's for — for shoes, books, or groceries!"
Visibility modifiers for variablesAlex wonders:
— "Interesting, who can actually see my variables? Can any user look at what's stored in my contract? Or are there ways to hide information?"
public – the variable can be read by everyone. A getter function is automatically created, allowing everyone to read the variable value from outside the contract. For example, for uint256 public counter a function function counter() public view returns (uint256) will be created, which any contract or user can use to read the counter variable value.
private – the variable is accessible for reading only within this contract, even inheriting contracts cannot read it
internal – the variable is accessible for reading within the contract and its inheritors (default for variables)
By default, variables are declared as internal.
Important: The public modifier only allows reading the variable from outside the contract, but doesn't affect the ability to modify it. Only functions inside the contract can modify the variable. To make a variable modifiable from outside, you need to create a special function for that.
Also important: The internal or private modifiers don't allow hiding or encrypting information! They only restrict the ability of other smart contracts to access it. In blockchain, all data is public, so state variables are not suitable for storing secret information.
Alex decided to understand variables better and created a smart contract to experiment with variables. He tries a simple example:
Solidity
﻿
contract SimpleStorage {
    // This is a variable named "message" that stores text.
    // Accessible only within the contract
    string message;
﻿
    // This is a variable named "number" that stores a number.
    // Accessible only within the contract and its child contracts
    uint256 number;
﻿
    // This is a variable named "publicNumber" that stores a number.
    // Accessible to everyone
    uint256 public publicNumber;
﻿
    // This is a variable named "privateBool" that stores a boolean value – true or false.
    // Accessible only within the contract
    bool private privateBool;
﻿
    // This is a variable named "internalAddress" that stores an address.
    // Accessible only within the contract and its child contracts
    address internal internalAddress;
}
﻿
One variable stores text, another — a number. Alex understands: variables are different. There are string variables — for text. There are numeric variables — for mathematical calculations. There are boolean values — true or false. There are addresses — for storing data about owners and users.
Default variable initializationAlex notices an interesting feature:
— "What if I declare a variable but don't assign it a value? What will be stored in it?"
He studies the documentation and learns an important rule: in Solidity all variables are automatically initialized with default values.
Each data type has a default value that will be stored in the variable if no value is assigned to it.
Default values for different typesSolidity
contract DefaultValues {
    // Numeric types are initialized to zero
    uint256 public number;           // 0
    int256 public signedNumber;      // 0
    uint8 public smallNumber;        // 0
﻿
    // Boolean type is initialized to false
    bool public flag;                // false
﻿
    // Address is initialized to zero address
    address public userAddress;      // 0x0000000000000000000000000000000000000000
﻿
    // Strings and bytes are initialized empty
    string public message;           // ""
    bytes public data;               // 0x (empty byte array)
﻿
    // Arrays are initialized empty
    uint256[] public numbers;        // []
    address[] public users;          // []
}
— "So, in Solidity there are no uninitialized variables! This is safe — no risk of using 'garbage' data."
Explicit initializationAlex also learns that you can explicitly initialize a variable — that is, assign it an initial value. This can be done in two ways:
Initialization at declarationThe simplest way — assign a value to the variable immediately when declaring it:
Solidity
contract DirectInitialization {
    // Initialization immediately at declaration
    uint256 public counter = 100;              // Counter starts at 100
    string public greeting = "Hello, world!";   // Welcome message
    bool public isActive = true;               // Contract is active by default
    address public admin = 0x1234567890AbcdEF1234567890AbcdEF12345678;  // Fixed admin address
﻿
    // Can use mathematical expressions
    uint256 public maxUsers = 1000 * 100;      // Maximum 100,000 users
    uint256 public fee = 5;                    // 5% fee
}
This method is suitable for values that are:
Known in advance at the code writing stage
The same for all contract instances
Don't depend on external conditions
Initialization in constructorAlex learns about constructor — a special function that executes once when creating a contract.
— "Constructor is like a ship launching ceremony. It happens only once, when the contract appears in the blockchain. After that, the constructor is never called again."
What is a constructor?Constructor — is a special function that:
Executes automatically when deploying the contract
Can accept parameters from the contract creator
Is used to configure the initial state
Is called only once in the contract's lifetime
Solidity
contract ConstructorInitialization {
    // Variables that will be initialized in the constructor
    address public owner;
    uint256 public creationTime;
    uint256 public initialBalance;
    string public contractName;
﻿
    // Constructor executes when creating the contract
    constructor(string memory _name, uint256 _balance) {
        owner = msg.sender;              // Owner — the one who created the contract
        creationTime = block.timestamp;  // Contract creation time
        initialBalance = _balance;       // Initial balance passed as parameter
        contractName = _name;            // Contract name passed as parameter
    }
}
This method is suitable for values that:
Depend on contract creation conditions (who created, when created)
Are passed as parameters during deployment
Are calculated based on blockchain state at creation time
Choosing initialization methodAlex derives rules for choosing between different initialization methods:
1. Initialization at declarationUse when values are known in advance and fixed:
Solidity
contract TokenSettings {
    uint256 public maxSupply = 1000000;        // Maximum number of tokens
    string public name = "MyToken";            // Token name
    uint8 public decimals = 18;                // Number of decimal places
    uint256 public transferFee = 5;            // Transfer fee (5%)
}
2. Initialization in constructorUse when values depend on creation conditions:
Solidity
contract DynamicContract {
    address public owner;
    uint256 public creationTime;
    uint256 public initialSupply;
    string public customName;
﻿
    constructor(string memory _name, uint256 _supply) {
        owner = msg.sender;           // Depends on who creates the contract
        creationTime = block.timestamp; // Depends on creation time
        initialSupply = _supply;      // Passed as parameter
        customName = _name;           // Configured at creation
    }
}
3. Default valuesUse when zero value is suitable:
Solidity
contract UserStats {
    uint256 public score;        // Automatically 0 — new users start from zero
    bool public isVerified;      // Automatically false — users are not verified
    uint256 public lastLogin;    // Automatically 0 — haven't logged in yet
}
— "Now I understand! Solidity takes care of safety itself — no random values. And I can choose the most suitable method for each variable."
Complex practical exampleAlex decides to create a gaming platform contract that demonstrates all initialization methods:
Solidity
contract GamePlatform {
    // === 1. INITIALIZATION AT DECLARATION ===
    // Used for fixed game settings
    string public constant PLATFORM_NAME = "CryptoGameHub";  // Constant
    uint256 public maxPlayers = 1000;                        // Maximum players
    uint256 public entryFee = 0.01 ether;                   // Entry cost
    bool public isMaintenanceMode = false;                   // Maintenance mode disabled
﻿
    // === 2. DEFAULT VALUES ===
    // Used when zero values are suitable
    uint256 public totalGamesPlayed;     // 0 - no games yet
    uint256 public totalPrizePool;       // 0 - prize pool empty
    bool public seasonStarted;           // false - season not started
﻿
    // === 3. INITIALIZATION IN CONSTRUCTOR ===
    // Used for dynamic values
    address public owner;                // Platform owner
    uint256 public platformLaunchTime;   // Platform launch time
    uint256 public seasonNumber;         // Current season number
    string public welcomeMessage;        // Personalized welcome
﻿
    constructor(uint256 _seasonNumber, string memory _message) {
        // Values depending on contract creator
        owner = msg.sender;                     // The one who deployed the contract
        platformLaunchTime = block.timestamp;   // Current blockchain time
﻿
        // Values passed at creation
        seasonNumber = _seasonNumber;           // Season number set at creation
        welcomeMessage = _message;              // Message is configured
    }
}
— "Excellent! Now I see how different initialization methods work together. Each has its purpose and helps make code more understandable and efficient."
Practical assignment on variable initializationAlex studied the theory of variable initialization and decided to apply the knowledge in practice:
— "Now I know how to properly declare variables! Let me try to create a contract for storing information about a defi platform."
But when he started writing code, he made several mistakes. Help Alex fix the problems with variable initialization.
Практические задания
Загрузка...
Additional materialsOfficial documentation﻿Solidity by example – Variables﻿
﻿Solidity Documentation - Variables — detailed description of state variables
﻿Solidity Documentation - Constants — guide on constants and immutable variables