Understanding the basics of Solidity Smart Contracts

Harry Thuku May 15, 2023, 2:20 p.m.

Contracts in Solidity have become an integral part of developing decentralized applications on the Ethereum blockchain. They are self-executing code, written in Solidity, which allow developers to create and manage digital assets and execute complex business logic in a transparent and trustless manner. Solidity is a high-level programming language that is specifically designed for creating smart contracts on the Ethereum blockchain. It is similar to other programming languages in terms of syntax and structure, but it has unique features and limitations that make it ideal for creating secure and efficient smart contracts. In this article, we will explore the basics of Solidity contracts and cover important topics such as constructors, state variables, functions, and visibility quantifiers. These topics are essential to understanding how Solidity contracts work and how they are used to build decentralized applications. We will dive into the details of each topic and explain how they work together to create powerful and secure smart contracts. Firstly, we will discuss constructors, which are a special type of function in Solidity that is executed only once during the deployment of a contract. Constructors are used to initialize the state variables of the contract and perform any other setup tasks that are required. We will provide examples and explain the syntax of constructors in Solidity. Secondly, we will cover state variables, which are used to store data in a contract. State variables are declared at the contract level and can be accessed by any function within the contract. We will explain the different data types that can be used for state variables and their limitations. Thirdly, we will discuss functions, which are used to define the behavior of a contract. Functions can be called by external parties or by other functions within the contract. We will explain the different visibility quantifiers in Solidity, which determine who can call the function and how the function can be called. The visibility quantifiers are external, public, internal, and private. Lastly, we will cover visibility quantifiers, which are used to specify who can access a function or state variable. We will explain each visibility quantifier and provide examples of how they are used in Solidity contracts. By the end of this article, you will have a solid understanding of the basics of Solidity contracts and be able to create your own smart contracts. So, let's dive in and explore the exciting world of Solidity contracts.

basics of solidity smart contracts

Constructors

In Solidity, constructors are executed only once during the deployment of the contract. They are used to initialize the state variables of the contract and perform any other setup tasks that are required. To define a constructor in Solidity, you use the constructor keyword followed by the function definition. Here's an example of a simple constructor:

NOTE: Incase you are wondering, its impossible to call a function inside a constructor because the contract functions do not exist yet (as the contract has not been deployed yet).

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract MyContract {
    uint public myNumber;

    constructor() {
        myNumber = 42;
    }
}
                                        
                                    

In the example above, we have a contract called MyContract with a single state variable myNumber of type uint (unsigned integer). The constructor is defined using the constructor keyword and sets the initial value of myNumber to 42. Constructors can also take parameters. Let's consider another example:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract Person {
    string public name;
    uint public age;

    constructor(string memory _name, uint _age) {
        name = _name;
        age = _age;
    }
}
                                        
                                    

In this example, the Person contract has two state variables: name of type string and age of type uint. The constructor takes two parameters, _name and _age, and assigns their values to the corresponding state variables. It's important to note that in Solidity, you can only have one constructor per contract, and its name must be the same as the contract name. The constructor is automatically invoked when the contract is deployed. By utilizing constructors, you can set initial values for state variables or perform any other necessary initialization tasks when deploying a contract on the Ethereum blockchain. Constructors play a crucial role in the setup and configuration of smart contracts. In the next section, we will delve into state variables and understand how they are used to store data within Solidity contracts.

State Variables

State variables in Solidity are used to store data within a contract. They hold information that can be accessed and modified by various functions within the contract. In this section, we will explore state variables in Solidity and provide code examples to illustrate their usage. To declare a state variable in Solidity, you specify the visibility (public, private, internal, or external) and the data type of the variable. Here's an example of a contract with state variables:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git

contract MyContract {
    uint public myNumber; // public state variable
    string private myString; // private state variable
    bool internal myFlag; // internal state variable

    constructor() {
        myNumber = 42;
        myString = "Hello, World!";
        myFlag = true;
    }
}
                                        
                                    

In the previous example, the MyContract contract showcases the usage of different visibility specifiers for its state variables: myNumber, myString, and myFlag. The myNumber variable is declared as public, allowing it to be accessed and read by any external entity interacting with the contract. On the other hand, the myString variable is declared as private, which confines its accessibility solely to functions within the contract. External parties are unable to access or modify it directly. The myFlag variable is declared as internal, enabling access by functions within the contract and by derived contracts that inherit from MyContract. Solidity supports a diverse range of data types for state variables, such as integers (uint, int), booleans (bool), strings (string), addresses (address), and more. These data types are available to accommodate various requirements and data structures. It's crucial to consider the storage implications and gas costs associated with modifying state variables since they consume storage space on the Ethereum blockchain. Prudent design and management of state variables are necessary to optimize efficiency. State variables can be read and modified by functions within the contract, which brings us to the next section where we will delve into functions and their significance in defining a contract's behavior.

Functions

Functions in Solidity play a pivotal role in defining the behavior of a contract. They enable the execution of specific actions and the manipulation of data within the contract. In this section, we will explore functions in Solidity and their various visibility quantifiers. Let's dive in! In Solidity, functions are declared using the function keyword followed by the function name, any parameters it may have, and an optional return type. Here's an example of a basic function within the MyContract contract:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract MyContract {
    uint public myNumber;

    function setNumber(uint _newNumber) public {
        myNumber = _newNumber;
    }
}
                                        
                                    

In the previous example, we introduced the setNumber function, which takes a parameter _newNumber of type uint (unsigned integer). This function is declared as public, indicating that it can be accessed both internally within the contract and externally by other parties interacting with the contract. By assigning the value of _newNumber to the state variable myNumber, the function effectively updates its value, showcasing how functions can modify state variables within a contract. Solidity provides four visibility quantifiers for functions: external, public, internal, and private. The external visibility quantifier specifies that a function can only be called externally by other contracts or transactions. It cannot be accessed internally by other functions within the same contract. This visibility quantifier is useful when you want to define functions that are explicitly intended for external interaction. On the other hand, the public visibility quantifier allows functions to be accessed both internally within the contract and externally by other contracts or transactions. It provides the broadest visibility, enabling versatile accessibility for various use cases. The internal visibility quantifier confines function access to the contract itself and derived contracts that inherit from it. It prevents external access but allows internal interaction within the contract hierarchy. This visibility quantifier is typically used when you want to create functions that are meant for internal contract logic. Lastly, the private visibility quantifier restricts function access solely to the contract in which it is defined. Private functions are not accessible externally or even by derived contracts. They are commonly employed to encapsulate internal logic or utility functions that are not intended for external or derived contract usage. Here's an example showcasing the different visibility quantifiers within the MyContract contract:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract MyContract {
    uint public myNumber;

    function setNumberExternal(uint _newNumber) external {
        myNumber = _newNumber;
    }

    function setNumberPublic(uint _newNumber) public {
        myNumber = _newNumber;
    }

    function setNumberInternal(uint _newNumber) internal {
        myNumber = _newNumber;
    }

    function setNumberPrivate(uint _newNumber) private {
        myNumber = _newNumber;
    }
}
                                        
                                    

In this example, we have four functions with different visibility quantifiers. The setNumberExternal function is declared as external, setNumberPublic as public, setNumberInternal as internal, and setNumberPrivate as private. Understanding the appropriate visibility quantifier for functions is crucial in designing secure and efficient contracts. It ensures that functions are accessible to the intended parties while properly encapsulating sensitive internal logic. Moving forward, we will delve into visibility quantifiers and their significance in specifying access to functions and state variables.

Visibility quantifiers

Visibility quantifiers in Solidity are used to specify who can access functions or state variables within a contract. They play a vital role in controlling the accessibility and encapsulation of contract elements. In this section, we will explore the different visibility quantifiers: external, public, internal, and private.

External

Functions or state variables declared as external can only be accessed externally by other contracts or transactions. They cannot be accessed internally within the contract. External functions are typically used when you want to define an interface for other contracts to interact with your contract. Example:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract MyContract {
    function myFunction() external {
        // Function logic
    }
}
                                        
                                    

Public

Functions or state variables declared as public can be accessed both internally within the contract and externally by other contracts or transactions. The visibility is the broadest for public elements. Public functions are often used for providing read access to contract state or for implementing contract interfaces. Example:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract MyContract {
    uint public myVariable;
    
    function myFunction() public {
        // Function logic
    }
}
                                        
                                    

Internal

Functions or state variables declared as internal can only be accessed internally within the contract or by derived contracts that inherit from the current contract. They cannot be accessed externally. Internal visibility is useful for defining functions or state variables that should only be accessed within the contract or its derived contracts. Example:

                                        
                                            // https://github.com/htostudios/solidity-contracts.git
contract MyContract {
    uint internal myVariable;
    
    function myFunction() internal {
        // Function logic
    }
}
                                        
                                    

Private

Functions or state variables declared as private are the most restricted in visibility. They can only be accessed within the contract where they are defined and cannot be accessed externally or even by derived contracts. Private visibility is commonly used for encapsulating internal logic or utility functions that should not be accessed externally. Example:

                                        
                                            // https://github.com/htostudios/abstract-contracts.git
contract MyContract {
    uint private myVariable;
    
    function myFunction() private {
        // Function logic
    }
}
                                        
                                    

Choosing the appropriate visibility quantifier is crucial for designing secure and efficient contracts. It ensures that functions and state variables are accessed by the intended parties, while restricting access to sensitive internal operations. By understanding and utilizing the visibility quantifiers effectively, developers can ensure proper encapsulation, access control, and security within their smart contracts. In the next section, we will summarize the key points covered in this article and provide a brief conclusion.

In this article, we have explored the basics of Solidity smart contracts, a crucial component in developing decentralized applications on the Ethereum blockchain. We started by understanding what Solidity contracts are and how they enable transparent and trustless execution of code. We delved into the essential elements of Solidity contracts, including constructors, state variables, functions, and visibility quantifiers. Constructors allow us to initialize the state variables and perform setup tasks during contract deployment. State variables store data within the contract, and we learned about different data types and their limitations. Functions define the behavior of the contract, and we examined the visibility quantifiers that control their accessibility. The external, public, internal, and private visibility quantifiers determine who can call the function and how it can be accessed. Throughout the article, we provided code examples to illustrate the concepts discussed. By applying these concepts effectively, developers can create powerful and secure smart contracts that cater to various use cases on the Ethereum blockchain. Understanding Solidity contracts and their associated features is crucial for building decentralized applications and contributing to the blockchain ecosystem. With this knowledge, you can harness the potential of smart contracts to create innovative solutions and participate in the exciting world of decentralized finance, decentralized applications, and more. As you continue your journey in blockchain development, it is essential to stay updated with the latest advancements in Solidity and the Ethereum ecosystem. Keep exploring, learning, and experimenting to unlock the full potential of smart contracts and their transformative capabilities. Now that you have a solid understanding of the basics of Solidity smart contracts, you are well-equipped to dive deeper into the world of blockchain development and create your own decentralized applications. Happy coding!