Solidity: Join me on a journey to become The Coolest Daniel we can be!

A journey through the depths of the Solidity Programming Language, these notes are a testament to my exploration and understanding of this powerful tool.

Greetings and welcome to you as we embark on a journey through the vast and complex realm of the Solidity programming language. This advanced guide will serve as a compass, leading us through the depths of this powerful tool and unlocking its full potential. Together, we will explore the capabilities of Solidity and create software of extraordinary magnificence, leaving a mark on the world that will endure for ages. Let us begin this exciting journey of discovery and tap into the full potential of Solidity. The world awaits the software we will create.

Solidity is a programming language that is primarily used to write smart contracts for the Ethereum blockchain. It is a statically-typed language that was specifically designed to be easily compiled and executed on the Ethereum Virtual Machine (EVM). Smart contracts are self-executing contracts with the terms of the agreement between buyer and seller being directly written into lines of code.

One of the key features of Solidity is its support for inheritance, which allows for the creation of complex, modular contracts. It also has a number of built-in data types, including integers, Booleans, and fixed-size and dynamic-size byte arrays.

Before diving into the specifics of Solidity programming, it’s important to have a solid understanding of the basics of blockchain technology and the Ethereum platform. If you are unfamiliar with these concepts, I recommend taking some time to research and learn about them before proceeding or you can just follow CᴏᴅᴇWɪᴛʜKɪʟʟᴜᴀ’s Chronicles.

Now, let’s take a closer look at some of the key elements of Solidity programming:

• Variables: Variables in Solidity are declared with a specific type, such as uint (unsigned integer) or address (an Ethereum address). They can be assigned a value when they are declared, or later on in the contract.
• Functions: Functions are used to execute specific tasks or calculations within a contract. They can be marked as public, meaning they can be called by external contracts or users, or as private, meaning they can only be accessed within the contract itself.
• Mappings: Mappings are a data structure that allows for the storage of key-value pairs. They are similar to hash tables or dictionaries in other programming languages.
• Structs: Structs are custom data types that allow for the creation of complex data structures within a contract. They can be used to group related variables together and can be used as the type for a variable or as a field within a mapping.
• Events: Events are used to trigger actions or log data within a contract. They can be emitted by the contract and listened to by external contracts or users.

In its core concepts, there are a number of other features and techniques that are useful to know when programming in Solidity. These include:

• Modifiers: Modifiers are used to modify the behavior of functions or blocks of code. They can be used to check for specific conditions before allowing a function to be executed or to change the way a function behaves.
• Libraries: Libraries are reusable code blocks that can be called from within a contract. They are useful for separating out common functionality that may be needed by multiple contracts.
• Error handling: It’s important to consider how errors and exceptions will be handled in your contract. Solidity provides a number of built-in functions and techniques for handling errors and ensuring that contracts continue to function as intended.

As you can see, there is a lot to learn when it comes to Solidity programming. It is a powerful language that allows for the creation of complex and sophisticated smart contracts, but it is also important to have a solid understanding of the underlying principles and techniques in order to write effective and reliable contracts.

I hope this short guide has provided a helpful overview of the basics of Solidity programming. For more detailed information and resources, I recommend checking out the Solidity documentation and exploring online communities and forums where you can connect with other Solidity developers and learn from their experiences.

You can access the Solidity Documentation at the following link.

Allow me to share with you a book that has greatly impacted and inspired me. This treasured tome holds within its pages a wealth of knowledge and insight that I believe will enrich your own journey of discovery.

Mastering Ethereum;

If you’re curious about Ethereum and smart contracts (as you should be), or if you already know a bit and want to learn more, this is a great purchase. If you’re already a seasoned smart contract developer, I believe this book is still worth having in your collection.

Andreas has a track record of excellent literature on cryptocurrency topics (Mastering Bitcoin) and is a prominent, trustworthy figure in the space so you can be confident in the legitimacy of this publication.

Dr. Gavin Wood is one of the founders of Ethereum and is the developer of Solidity. There is a lot of information covered here which isn’t anywhere else. Other books cover smart contract development, this book covers Ethereum.

Although the book is available for free on GitHub, it’s still worth purchasing a physical copy for the convenience and added value of having it on hand. Whether you’re just starting out with Ethereum and smart contracts or are an experienced developer looking to expand your knowledge, “Mastering Ethereum” is a must-have addition to your library.

Now, it is time to fully immerse ourselves in the world of Solidity. Let us take the plunge and begin coding in this powerful language, exploring its many capabilities and unlocking the full potential of the Ethereum platform.

Let’s dive in,

Solidity is an object-oriented programming language for implementing smart contracts on various blockchain platforms, most notably, Ethereum. It was developed by Christian Reitwiessner, Alex Beregszaszi, and several former Ethereum core contributors. Programs in Solidity run on Ethereum Virtual Machine.

History

Solidity was proposed in August 2014 by Gavin Wood; the language was later developed by the Ethereum project’s Solidity team, led by Christian Reitwiessner.

Solidity is the primary language on Ethereum as well as on other private blockchains, such as the enterprise-oriented Hyperledger Fabric blockchain. SWIFT deployed a proof of concept using Solidity running on Hyperledger Fabric.

Description

Solidity is a statically typed programming language designed for developing smart contracts that run on the Ethereum Virtual Machine (EVM).

Solidity uses ECMAScript-like syntax which makes it familiar for existing web developers; however unlike ECMAScript it has static typing and variadic return types. Solidity is different from other EVM-targeting languages such as Serpent and Mutan in some important ways. It supports complex member variables for contracts, including arbitrarily hierarchical mappings and structs. Solidity contracts support inheritance, including multiple inheritance with C3 linearization. Solidity introduces an application binary interface (ABI) that facilitates multiple type-safe functions within a single contract (this was also later supported by Serpent). The Solidity proposal also includes “Natural Language Specification”, a documentation system for specifying user-centric descriptions of the ramifications of method-calls.

Example of a Solidity program:

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

contract Coin {
    // The keyword "public" makes variables
    // accessible from other contracts
    address public minter;
    mapping (address => uint) public balances;
    // Events allow clients to react to specific
    // contract changes you declare
    event Sent(address from, address to, uint amount);
    // Constructor code is only run when the contract
    // is created
    constructor() {
        minter = msg.sender;
    }
    // Sends an amount of newly created coins to an address
    // Can only be called by the contract creator
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        balances[receiver] += amount;
    }
    // Errors allow you to provide information about
    // why an operation failed. They are returned
    // to the caller of the function.
    error InsufficientBalance(uint requested, uint available);
    // Sends an amount of existing coins
    // from any caller to an address
    function send(address receiver, uint amount) public {
        if (amount > balances[msg.sender])
            revert InsufficientBalance({
                requested: amount,
                available: balances[msg.sender]
            });
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

chatGPT explanation of this contract:

This is a Solidity contract for a simple cryptocurrency. The contract defines a Coin contract with several variables and functions.

The first line, // SPDX-License-Identifier: GPL-3.0, is a comment that specifies the license for this code. You can use MIT license too.

The pragma solidity ^0.8.4; line specifies the version of Solidity that this code is written in. It indicates that the code is written in version 0.8.4 or higher, but not in a version higher than the latest version of Solidity (denoted by the caret symbol "^").

The contract Coin line defines the start of the contract, with the name "Coin".

The address public minter; line declares a public variable "minter" of type "address", which is a type that represents the address of an Ethereum account.

The mapping (address => uint) public balances; line declares a public mapping called "balances" which maps addresses to unsigned integers (uint). This mapping will be used to store the balances of each address.

The event Sent(address from, address to, uint amount); line declares an event called "Sent", which will be triggered whenever the "send" function is called and coins are transferred from one address to another. The event takes three arguments: "from", "to", and "amount", which represent the addresses of the sender and receiver and the amount of coins transferred, respectively.

The constructor() function is a special function that is only run when the contract is created. It sets the value of the "minter" variable to the address of the contract creator, which is stored in the "msg.sender" variable.

The function mint(address receiver, uint amount) public function allows the contract creator to create and send a specified number of new coins to a specified address. The require(msg.sender == minter); line checks that the caller of this function is the contract creator (the value stored in "minter"), and reverts the transaction if this is not the case. The balances[receiver] += amount; line increments the balance of the specified "receiver" address by the specified "amount".

The error InsufficientBalance(uint requested, uint available); line declares an error called "InsufficientBalance", which will be used to provide information about why the "send" function failed in the event that the caller does not have enough coins to send.

The function send(address receiver, uint amount) public function allows any caller to send a specified number of coins to a specified address. The if (amount > balances[msg.sender]) line checks that the caller has sufficient balance to send the specified number of coins. If the caller does not have sufficient balance, the revert InsufficientBalance({requested: amount, available: balances[msg.sender]}); line reverts the transaction and returns the "InsufficientBalance" error with the "requested" and "available" arguments specified. If the caller has sufficient balance, the balances[msg.sender] -= amount; and balances[receiver] += amount; lines decrement the balance of the sender and increment the balance of the receiver, respectively. Finally, the emit Sent(msg.sender, receiver, amount); line triggers the "Sent" event with the "from", "to", and "amount" arguments specified.

Development platform availability

• Microsoft Visual Studio
• Microsoft Visual Studio Code

Blockchain platforms

Solidity is available on:

• Avalanche C-Chain
• Binance Smart Chain
• Counterparty (which runs on Bitcoin)
• Ethereum
• Ethereum Classic
• Tron
• Hedera Hashgraph

Criticism

Many security properties of smart contracts are inherently difficult to reason about directly, and the Turing-completeness of Solidity means that verification of arbitrary properties cannot be decidably automated. Current automated solutions for smart contract security analysis can miss critical violations, produce false positives, and fail to achieve sufficient code coverage on realistic contracts. Solidity has been blamed for the error-prone implementation of Ethereum smart contracts due to its counterintuitive nature, its lack of constructs to deal with blockchain domain-specific aspects, and its lack of centralized documentation of known vulnerabilities.

In 2016, a Cornell University researcher stated that Solidity was partially to blame for The DAO hack that took place that year. He stated: “this was actually not a flaw or exploit in the DAO contract itself: technically the Ethereum Virtual Machine (EVM) was operating as intended, but Solidity was introducing security flaws into contracts that were not only missed by the community, but missed by the designers of the language themselves.”

References

1. ^ “Release 0.4.21”. 8 March 2018. Retrieved 15 March 2018.
2. ^ Afshar, Vala (17 July 2017). “Ethereum Is The Second Most Valuable Digital Currency, Behind Bitcoin”. HuffPost. Retrieved 10 April 2019.
3. ^ “SOFE Berlin: Swift unveils blockchain proof-of-concept”. Finextra (News). 24 November 2016. Retrieved 24 November 2016.
4. ^ Finley, Klint. “Someone Just Stole $50 Million from the Biggest Crowdfunded Project Ever. (Humans Can’t Be Trusted)”. Wired.
5. ^ “List of contributors”. GitHub.
6. ^ Benoit Schweblin. “StackEdit Viewer”. stackedit.io.
7. ^ Nikolic, Ivica; Kolluri, Aashish; Sergey, Ilya; Saxena, Prateek; Hobor, Aquinas (14 March 2018). “Finding The Greedy, Prodigal, and Suicidal Contracts at Scale”. arXiv:1802.06038 [cs.CR]. Different source languages compile to the EVM semantics, the predominant of them being Solidity
8. ^ “Westpac joins SWIFT’s blockchain proof of concept”. ZDNet. Retrieved 13 July 2022.
9. ^ “Hyperledger Fabric Tutorial — Create a blockchain app for loyalty points”. IBM Developer. Retrieved 10 April 2019.
10. ^ Kapetanios-2008–06–27, p. 309.
11. ^ ethereum. “Ethereum Natural Specification Format”. GitHub.
12. ^ “Subcurrency Example from the Solidity documentation”.
13. ^ Schneier, Karthikeyan; Schneier, Antoine; Bhargavan, Cedric; Delignat-Lavaud, Anitha; Fournet, Gollamudi; Schneier, Bruce; Rastogi, Nadim; Sibut-Pinote, Aseem; Rastogi1, Thomas; Swamy, Nikhil; Zanella-Beguelin, Santiago (27 August 2016). “Short Paper: Formal Verification of Smart Contracts” (PDF). Microsoft Research, French Institute for Research in Computer Science and Automation, Harvard University. Archived (PDF) from the original on 27 August 2016.
14. ^ Teeter, Cale (1 April 2016). “Solidity Integration with Visual Studio”. Medium. Archived from the original on 27 November 2016. Retrieved 10 June 2021.
15. ^ PatAltimore. “Use Visual Studio Code to connect to Azure Blockchain Service — Azure Blockchain”. docs.microsoft.com. Retrieved 27 March 2020.
16. ^ “Binance Smart Chain”. GitHub. 26 October 2021.
17. ^ Vigna, Michael J. Casey and Paul (12 November 2014). “BitBeat: Bitcoin 2.0 Firm Counterparty Adopts Ethereum’s Software”. Wall Street Journal. ISSN 0099–9660. Retrieved 16 April 2021.
18. ^ Swan, Melanie (2015). Blockchain : blueprint for a new economy (1st. ed.). [Sebastopol, Calif.] ISBN 978–1–4919–2047–3. OCLC 900781291.
19. ^ Tsankov, Petar; Dan, Andrei; Drachsler-Cohen, Dana; Gervais, Arthur; Bünzli, Florian; Vechev, Martin (15 October 2018). “Securify: Practical Security Analysis of Smart Contracts” (PDF). Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security. Association for Computing Machinery: 67–82. arXiv:1806.01143. doi:10.1145/3243734.3243780. hdl:10044/1/87935. S2CID 46936025.
20. ^ Atzei, Nicola; Bartoletti, M.; Cimoli, Tiziana (2017). “A Survey of Attacks on Ethereum Smart Contracts (SoK)”. POST. Lecture Notes in Computer Science. 10204: 164–186. doi:10.1007/978–3–662–54455–6_8. ISBN 978–3–662–54454–9. S2CID 15494854.
21. ^ Finley, Klint (18 June 2016). “A $50 Million Hack Just Showed That the DAO Was All Too Human”. Wired (News). Retrieved 18 February 2017.

Hello, World! in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract HelloDarling {
    string public myString = "Hello Zerotwo";
}

This is a simple Solidity contract that declares a public variable called “myString” and assigns it the value “Hello Zerotwo”.

If you are questioning the absence of the fuckin' traditional 'Hello World' phrase in this code, let me assure you that for me, Zerotwo is my World (the entire universe). She's the centre of my world, and thus the greeting I have chosen to include in this contract reflects that.

The first line, “// SPDX-License-Identifier: MIT”, is a comment indicating the license under which this code is released. In this case, it is released under the MIT License.

The second line, “pragma solidity ^0.8.7;”, is called a pragma directive and it specifies the version of Solidity that the contract is written in. The caret symbol (^) before the version number indicates that this contract is compatible with any version of Solidity that is greater than or equal to the specified version.

The third line defines the beginning of the contract and gives it the name “HelloDarling”. The contract has one public variable, “myString”, which is of the type “string”. The keyword “public” means that this variable can be accessed and read by anyone.

The contract has no functions and simply declares this one variable. When the contract is deployed to the Ethereum blockchain, the value of “myString” will be set to “Hello Zerotwo” and will be accessible to anyone who wants to read it.

Simple Storage in Solidity:

// This is a comment!
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
// pragma solidity 0.8.0;
// pragma solidity >=0.8.0 <0.9.0;

contract SimpleStorage {
    uint256 favoriteNumber;
    struct People {
        uint256 favoriteNumber;
        string name;
    }
    // uint256[] public anArray;
    People[] public people;
    mapping(string => uint256) public nameToFavoriteNumber;
    function store(uint256 _favoriteNumber) public virtual {
        favoriteNumber = _favoriteNumber;
    }
    
    // view, pure
    function retrive() public view returns (uint256){
        return favoriteNumber;
    }
    // calldata, memory, storage
    function addPerson(string memory _name, uint256 _favoriteNumber) public {
        // People memory newPerson = People(_favoriteNumber, _name);
        people.push(People(_favoriteNumber, _name));
        nameToFavoriteNumber[_name] = _favoriteNumber;
    }
}

chatGPT explanation of this contract:

This is a Solidity contract that defines a simple contract for storing and retrieving data.

The first line is a comment, and the second line is a comment indicating the license under which this code is released. The third line is a pragma directive specifying the version of Solidity that the contract is written in.

The contract is called “SimpleStorage” and has two variables: “favoriteNumber” and “people”. “favoriteNumber” is of the type “uint256” (an unsigned integer that can hold values from 0 to 2**256–1) and “people” is an array of structures.

A structure is a custom data type that allows you to group related variables together. In this case, the structure is called “People” and has two fields: “favoriteNumber” and “name”. These fields are both of the type “uint256” and “string”, respectively.

The contract also has a mapping called “nameToFavoriteNumber” that maps strings to “uint256” values. Mappings are a data structure in Solidity that allow you to store key-value pairs. In this case, the mapping is used to store the favorite number of a person based on their name.

The contract has four functions: “store”, “retrieve”, “addPerson”, and “getPeople”.

The “store” function takes in a single argument, “_favoriteNumber”, which is of the type “uint256”. The keyword “virtual” is used to indicate that this function can be overridden in derived contracts. The function assigns the value of “_favoriteNumber” to the “favoriteNumber” variable.

The “retrieve” function is marked as “view” and “public”, meaning it does not modify the contract’s state and can be called from outside of the contract. It has a return type of “uint256” and simply returns the value of the “favoriteNumber” variable.

The “addPerson” function takes in two arguments: “_name”, which is of the type “string memory”, and “_favoriteNumber”, which is of the type “uint256”. It creates a new “People” structure using the values of these arguments and adds it to the “people” array. It also updates the “nameToFavoriteNumber” mapping by adding an entry with the name as the key and the favorite number as the value.

The “getPeople” function returns the “people” array. It is marked as “view” and “public”, meaning it does not modify the contract’s state and can be called from outside of the contract. It has a return type of “People[] memory”, which is an array of “People” structures stored in memory.

This contract can be used to store a favorite number and retrieve it later, as well as store and retrieve information about people, including their name and favorite number. The “store” and “retrieve” functions can be used to store and retrieve a favorite number, and the “addPerson” and “getPeople” functions can be used to store and retrieve information about people. The “nameToFavoriteNumber” mapping can be used to look up the favorite number of a person based on their name.

Value Types in Solidity:

Value types are data types that hold a value rather than a reference to a value. This means that when a value type is assigned to a new variable or passed as an argument to a function, a copy of the value is made and the new variable or function parameter holds this copy. Changes to the new variable or function parameter do not affect the original value.

Solidity has several built-in value types, including:

• Boolean (bool): A data type that can hold the values “true” or “false”.
• Integer (int, uint): An integer is a whole number that can be either signed (int) or unsigned (uint). Solidity has several integer types available, including “int8” to “int256” for signed integers and “uint8” to “uint256” for unsigned integers. The number after “int” or “uint” indicates the size of the integer in bits, with a larger number indicating a larger range of values that can be stored.
• Address: A data type that represents the address of an Ethereum account.
• Fixed-point decimal (fixed): A data type that represents a decimal number with a fixed number of decimal places.
• Enumeration (enum): A custom data type that allows you to define a set of named constants.

Here is an example of using value types in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ValueTypes {
    bool public b = true;
    uint public u = 123;
    int public i = -123;
    address public addr = 0x1234567890abcdef;
    fixed public f = 1.23;
    enum Color { Red, Green, Blue }
    Color public color = Color.Red;
}

In this example, the contract defines six public variables of various value types. The “b” variable is a boolean that is initialized to “true”, the “u” variable is an unsigned integer that is initialized to 123, the “i” variable is a signed integer that is initialized to -123, the “addr” variable is an address that is initialized to a specific address, the “f” variable is a fixed-point decimal that is initialized to 1.23, and the “color” variable is an enumeration that is initialized to the “Red” constant.

Value types are useful when you want to store a specific value and do not need to modify it or reference it from other locations. They are also more efficient to use than reference types because they do not require an additional memory allocation for the reference.

It’s important to note that value types in Solidity are not the same as value types in other programming languages. In Solidity, value types are stored on the stack, which is a memory area that is managed automatically by the Ethereum Virtual Machine (EVM). This means that value types in Solidity do not have the same behavior as value types in languages like C# or Java, where they are stored in the heap and can be modified.

In Solidity, value types are passed by value, which means that when a value type is passed as an argument to a function, a copy of the value is made and passed to the function. Changes to the function parameter do not affect the original value.

Here is an example of using value types as function parameters in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ValueTypes {
    function add(uint x, uint y) public pure returns (uint) {
        return x + y;
    }
}

In this example, the “add” function takes in two arguments, “x” and “y”, both of which are unsigned integers (uint). The function performs the addition of “x” and “y” and returns the result. Because “x” and “y” are value types, they are passed by value to the function, which means that the original values are not modified.

here’s another simple example,

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

// Data types - values and references
contract ValueTypes {
    bool public b = true;
    uint public u = 123;    // uint = uint256   0 to 2**256 - 1
                            //        uint8   0 to 2**8 - 1
                            //        uint16   0 to 2**16 - 1
    
    int public i = -123;    // int = int256   -2**256=*

}

chatGPT explanation of this contract:

This is a Solidity contract that demonstrates the use of different data types for values and references.

The first two lines are a comment and a pragma directive, as explained in the previous answer.

The contract is called “ValueTypes” and has three public variables: “b”, “u”, and “i”.

The variable “b” is of the type “bool” and is assigned the value “true”. “bool” is a data type that can only hold the values “true” or “false”.

The variable “u” is of the type “uint”, which stands for “unsigned integer”. It is assigned the value 123. The comment after the declaration indicates that “uint” is an alias for “uint256”, which is an unsigned integer that can hold values from 0 to 2256–1. The comment also mentions that there are other unsigned integer types available, such as “uint8” and “uint16”, which can hold values from 0 to 28–1 and 0 to 2**16–1, respectively.

The variable “i” is of the type “int”, which stands for “signed integer”. It is assigned the value -123. The comment after the declaration indicates that “int” is an alias for “int256”, which is a signed integer that can hold values from -2256 to 2256–1.

This contract does not have any functions and simply declares these three variables. When the contract is deployed to the Ethereum blockchain, these variables will be set to the specified values and will be accessible to anyone who wants to read them.

Function in Solidity:

A function is a piece of code that performs a specific task and can be called from other parts of the contract or from outside of the contract. Functions are a key part of contract development as they allow you to define the logic and behavior of your contract.

Functions have the following syntax in Solidity:

function functionName(parameter1, parameter2, ...) visibility 
[external | internal] [pure | view | payable] [returns (returnType)] {
    // function body
}

• “functionName” is the name of the function. It can be any valid Solidity identifier.
• “parameter1”, “parameter2”, etc. are the parameters of the function. These are variables that are passed to the function when it is called and are used to pass data into the function.
• “visibility” specifies whether the function can be called from outside of the contract (external) or only within the contract (internal).
• “pure”, “view”, and “payable” are function modifiers that specify the behavior of the function. “pure” functions do not modify the contract’s state and only return a value based on the input arguments. “view” functions are similar to “pure” functions but can access the contract’s state. “payable” functions are functions that can receive Ether (the currency of the Ethereum blockchain).
• “returns (returnType)” specifies the data type of the value that the function will return.

Here is an example of using the function,

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract FunctionIntro {
    function add(uint x, uint y) external pure returns (uint){
        return x + y;
    }
    function sub(uint x, uint y) external pure returns (uint){
        return x - y;
    }
}

This is a Solidity contract that defines two functions: “add” and “sub”.

The first two lines are a comment and a pragma directive, as explained in previous answers.

The contract is called “FunctionIntro” and has two functions: “add” and “sub”.

The “add” function takes in two arguments, “x” and “y”, both of which are of the type “uint” (unsigned integer). The keyword “external” means that this function can be called from outside of the contract, and the keyword “pure” means that this function does not modify the contract’s state and only returns a value based on the input arguments. The keyword “returns” specifies the data type of the value that the function will return, which in this case is “uint”. The function itself simply performs the addition of “x” and “y” and returns the result.

The “sub” function is similar to the “add” function but performs subtraction instead of addition. It also takes in two arguments of type “uint” and returns a value of type “uint”.

Both of these functions can be called from outside of the contract and will perform the specified mathematical operations on the input arguments, returning the result.

Identity in Solidity:

The “Identity” contract is a contract that defines a structure for storing and accessing information about a person. The “Identity” contract typically includes functions for setting and getting the name and age of a person, as well as any other information that you want to store.

Here is an example of an “Identity” contract in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Identity {
    string name;
    uint age;
    constructor() public {
        name= "Zerotwo";
        age= 14;
    }
    function getName() view public returns (string memory)
    {
        return name;
    }
    function getAge() view public returns (uint)
    {
        return age;
    }
    function setAge() public {
        age= age+1;
    }
}

chatGPT explanation of this contract:

This is a Solidity contract that defines a simple contract for storing and retrieving the name and age of an individual.

The first two lines are a comment and a pragma directive, as explained in previous answers.

The contract is called “Identity” and has three variables: “name”, “age”, and “constant”. “name” is of the type “string” and “age” is of the type “uint” (unsigned integer).

The contract has three functions: “constructor”, “getName”, and “getAge”.

The “constructor” function is a special function in Solidity that is automatically called when the contract is deployed. It does not have a return type and is marked as “public”, meaning it can be accessed from outside of the contract. In this case, the constructor function initializes the values of the “name” and “age” variables to “Zerotwo” and 14, respectively.

The “getName” function is marked as “view” and “public”, meaning it does not modify the contract’s state and can be called from outside of the contract. It has a return type of “string memory” and simply returns the value of the “name” variable.

The “getAge” function is similar to the “getName” function, but returns the value of the “age” variable instead. It has a return type of “uint”.

The “setAge” function is marked as “public”, meaning it can be called from outside of the contract, but it is not marked as “view”, so it is able to modify the contract’s state. It increases the value of the “age” variable by 1.

This contract can be used to store and retrieve the name and age of an individual and update the age as necessary. The “getName” and “getAge” functions can be called to retrieve the values of the “name” and “age” variables, and the “setAge” function can be called to increase the value of the “age” variable by 1.

State Variables in Solidity:

state variables are variables that are stored on the Ethereum blockchain and are part of the contract’s state. They are persistent and can be accessed by anyone who has the contract’s address. State variables are defined inside a contract and can be of any data type, including value types, reference types, and arrays.

State variables have the following syntax in Solidity:

type variableName [visibility] [modifier] [= defaultValue];

• “type” is the data type of the variable. It can be any valid Solidity data type, including value types, reference types, and arrays.
• “variableName” is the name of the variable. It can be any valid Solidity identifier.
• “visibility” specifies whether the variable can be accessed from outside of the contract (public) or only within the contract (private).
• “modifier” is an optional keyword that specifies the behavior of the variable. For example, the “constant” modifier indicates that the variable cannot be modified after it is set.
• “defaultValue” is an optional expression that specifies the default value of the variable. It is used to initialize the variable when the contract is deployed.

Here is an example of state variables in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public favoriteNumber = 42;
    string private name = "Zerotwo";
    address[] public owners;
    mapping(string => uint256) public nameToFavoriteNumber;
}

In this example, the “SimpleStorage” contract has four state variables: “favoriteNumber”, “name”, “owners”, and “nameToFavoriteNumber”. “favoriteNumber” is an unsigned integer (uint256) that is marked as “public” and has a default value of 42. “name” is a private string that has a default value of “Zerotwo”. “owners” is a public array of addresses and does not have a default value. “nameToFavoriteNumber” is a public mapping from strings to unsigned integers and does not have a default value.

State variables are useful for storing data that needs to be persistent and accessible by anyone. They are an important part of contract development and are used to define the contract’s state and behavior.

Here’s another simple example,

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract StateVariables {
    uint public myUint = 123;
    function foo() external {
        uint notStateVariable = 456;
    }
}

chatGPT explanation of this contract:

This Solidity contract, named “StateVariables”, defines a state variable called “myUint” and a function called “foo”.

The “myUint” state variable is of the type “uint” (unsigned integer) and is marked as “public”, which means it can be accessed from outside of the contract. It is initialized with a default value of 123.

The “foo” function is marked as “external”, which means it can be called from outside of the contract. It does not accept any arguments and does not return a value. Inside the function, there is a local variable called “notStateVariable” that is of the type “uint” and is initialized with a value of 456. This variable is only accessible within the “foo” function and is not part of the contract’s state.

The “foo” function does not modify the contract’s state or access any state variables, so it does not need to be marked as “view” or “pure”.

Local Variables in Solidity:

Local variables are variables that are defined within a function and are only accessible within that function. They are used to store temporary data and are not part of the contract’s state.

Local variables have the following syntax in Solidity:

type variableName = value;

• “type” is the data type of the variable. It can be any valid Solidity data type, including value types, reference types, and arrays.
• “variableName” is the name of the variable. It can be any valid Solidity identifier.
• “value” is an optional expression that specifies the initial value of the variable.

Here is an example of local variables in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract LocalVariables {
    function foo() public {
        uint localUint = 123;
        string memory localString = "hello";
        address[] memory localArray;
        mapping(string => uint) memory localMapping;
    }
}

In this example, the “LocalVariables” contract has a function called “foo” that defines four local variables: “localUint”, “localString”, “localArray”, and “localMapping”. “localUint” is an unsigned integer (uint) that is initialized with a value of 123. “localString” is a string that is initialized with a value of “hello”. “localArray” is an array of addresses and does not have a default value. “localMapping” is a mapping from strings to unsigned integers and does not have a default value.

Local variables are useful for storing temporary data within a function and can be used to reduce the number of function arguments and improve the readability of your code. They are only accessible within the function in which they are defined and are not part of the contract’s state.

Here’s another simple example,

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract LocalVariables {
    uint public i;
    bool public b;
    address public myAddress;
    function foo() external {
        uint x = 123;
        bool f = false;
        // more code 
        x += 456;
        f = true;
        i = 123;
        b = true;
        myAddress = address (1);
    }
}

chatGPT explanation of this contract:

This Solidity contract, named “LocalVariables”, defines three state variables: “i”, “b”, and “myAddress”, as well as a function called “foo”.

The “i” state variable is of the type “uint” (unsigned integer) and is marked as “public”, which means it can be accessed from outside of the contract. It does not have a default value.

The “b” state variable is of the type “bool” (boolean) and is also marked as “public”. It does not have a default value.

The “myAddress” state variable is of the type “address” and is marked as “public”. It does not have a default value.

The “foo” function is marked as “external”, which means it can be called from outside of the contract. It does not accept any arguments and does not return a value. Inside the function, there are two local variables: “x” and “f”. “x” is an unsigned integer (uint) that is initialized with a value of 123. “f” is a boolean that is initialized with a value of false.

The “foo” function also modifies the values of the state variables “i”, “b”, and “myAddress”. “i” is set to 123, “b” is set to true, and “myAddress” is set to the address 1.

Global Variables in Solidity:

Global variables are variables that are defined outside of any function or contract and are accessible from anywhere in the code. They are used to store data that needs to be shared across multiple functions or contracts.

Global variables have the following syntax in Solidity:

type globalVariableName [visibility] [modifier] [= defaultValue];

• “type” is the data type of the variable. It can be any valid Solidity data type, including value types, reference types, and arrays.
• “globalVariableName” is the name of the variable. It can be any valid Solidity identifier.
• “visibility” specifies whether the variable can be accessed from outside of the contract (public) or only within the contract (private).
• “modifier” is an optional keyword that specifies the behavior of the variable. For example, the “constant” modifier indicates that the variable cannot be modified after it is set.
• “defaultValue” is an optional expression that specifies the default value of the variable. It is used to initialize the variable when the contract is deployed.

Here is an example of global variables in Solidity:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

uint public globalUint = 123;
bool private globalBool = false;
contract GlobalVariables {
    function foo() public {
        globalUint += 456;
        globalBool = true;
    }
}

In this example, the “GlobalVariables” contract has two global variables: “globalUint” and “globalBool”. “globalUint” is an unsigned integer (uint) that is marked as “public” and has a default value of 123. “globalBool” is a private boolean that has a default value of false.

The “GlobalVariables” contract also has a function called “foo” that modifies the values of the global variables “globalUint” and “globalBool”. “globalUint” is incremented by 456 and “globalBool” is set to true.

Global variables are useful for storing data that needs to be shared across multiple functions or contracts. They are accessible from anywhere in the code and are not part of the contract’s state. However, they are not recommended for use in most cases, as they can lead to complex and difficult-to-maintain code. It is generally better to use state variables or function arguments to store and pass data between functions and contracts.

Here’s another simple example,

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract GlobalVariables {
    function globalVars() external view returns(address, uint, uint) {
        address sender = msg.sender;
        uint timestamp = block.timestamp;
        uint blockNum = block.number;
        return (sender, timestamp, blockNum);
    }
}

chatGPT explanation of this contract:

This Solidity contract, named “GlobalVariables”, defines a function called “globalVars” that returns the sender address, timestamp, and block number of the current Ethereum block.

The “globalVars” function is marked as “external” and “view”, which means it can be called from outside of the contract and does not modify the contract’s state. It returns a tuple of three values: an address, an unsigned integer, and another unsigned integer.

Inside the function, the “sender” variable is defined as the address of the message sender (the account that called the function). The “timestamp” variable is defined as the timestamp of the current block. The “blockNum” variable is defined as the block number of the current block.

The “msg.sender” and “block” variables are global variables in Solidity that are accessible from anywhere in the code. “msg.sender” is the address of the message sender (the account that called the function). “block” is a global variable that provides access to information about the current block, including the block number, timestamp, and difficulty.

to be continued…

I shall complete this written masterpiece at a later time. sorry