Skip to main content
Version: 1.0

Introduction to Solidity

Solidity is a high-level, statically-typed programming language designed specifically for developing smart contracts that run on the Ethereum Virtual Machine (EVM). As a cornerstone of the Ethereum blockchain ecosystem, Solidity enables the creation of contracts for voting, crowdfunding, blind auctions, multi-signature wallets, and more. Its syntax is heavily influenced by JavaScript, C++, and Python, making it familiar and relatively easy to learn for developers with experience in any of those languages.

Core Concepts of Solidity​

Smart Contracts​

At its core, a smart contract is a self-executing contract with the terms of the agreement being directly written into lines of code. The code and the agreements contained therein exist across a distributed, decentralized blockchain network. Smart contracts permit trusted transactions and agreements to be carried out among disparate, anonymous parties without the need for a central authority, legal system, or external enforcement mechanism.

Ethereum Virtual Machine (EVM)​

The EVM is the runtime environment for smart contracts in Ethereum. It provides a sandboxed environment where all smart contracts are executed, ensuring that code runs exactly as written without access to the network, file system, or other processes.

Features of Solidity​

Static Typing: Variables' types are known at compile time, which helps in catching errors early.

Inheritance: Solidity supports both single and multiple inheritances, enabling contracts to derive properties and behaviors from multiple parent contracts.

Interfaces and Abstract Contracts: These features enable developers to define contracts that can interact with other contracts and enforce certain constraints within the Solidity ecosystem.

Libraries: Reusable pieces of code can be deployed independently and called from other contracts to perform utility functions, thereby saving gas.

Modifiers: Functions in Solidity can be modified to include preconditions that must be met before execution.

tip

The Remix IDE enables you to experiment with code samples straight from your web browser.

Simple Smart Contract Example​

We'll start with a simple code example that demonstrates how to assign a value to a variable and make it accessible to other contracts. Don't worry if some concepts aren't clear at first.

1_Storage.sol
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.8.2 <0.9.0;

contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}

Explanation​

Solidity code defines a simple smart contract named Storage that allows users to store and retrieve a uint256 value. This contract is compatible with Solidity compiler versions from 0.8.2 up to, but not including, 0.9.0. Here's a brief overview of its functionality:

  • Contract Name: Storage

  • Compiler Version: >=0.8.2 <0.9.0

  • License: GPL-3.0

Functions​

  1. store(uint256 num): This public function allows anyone to update the number stored in the contract by providing a new uint256 value as num. Once called, it updates the number variable with the value of num.

  2. retrieve(): This public view function allows anyone to retrieve the current value of the number stored in the contract. It returns the uint256 value of number.

Variables​

  • number (uint256): A state variable to hold the value that can be updated and retrieved through the store and retrieve functions, respectively.

Key Points​

  • Public Functions: Both functions are marked as public, meaning they can be called by anyone.

  • State Variable: number is a state variable, and its value is persistent across function calls and transactions.

  • View Function: The retrieve function is a view function, indicating it doesn't modify the state of the blockchain. It only reads and returns the value of number.

This contract is a straightforward example often used for educational purposes, demonstrating the basics of state management and function visibility in Solidity.