Smart contracts enable you to solve common problems in a way that maximizes trust. The purpose of contracts is to reduce ambiguity and inclination so that a predictable set of outcomes is produced, and these outcomes can be depended upon. In Ethereum, you can write smart contracts with the built-in Turing complete programming language (solidity). The language can create its own arbitrary rules for ownership, transaction formats, and state transition functions. Smart contracts in Ethereum are written in solidity and targeted to run on the Ethereum Virtual Machine (EVM). To actually execute smart contract code, someone has to send enough Ether as a transaction fee. The fee is calculated based on the computing resources required. This pays the miner nodes for participating and providing their computing power.

This chapter covers all the essentials of writing a smart...

Developing a distributed application often requires the developer to interact with multiple tools and languages. There are efficient Integrated Development Environments (IDE) that can help you accomplish most of the work related to developing an application. IDEs usually combine code editors, compilers, debuggers, and other useful tools. Some may find it comfortable using a simple text editor and related command-line tools for development.

In this recipe, you will learn about a few tools that can support Ethereum development.

One of the most popular and widely used IDEs for solidity is Remix. Let's see how you can use it for your development:

1. Access Remix by navigating to https...

Solidity is the language of choice for writing smart contracts in Ethereum. A solidity smart contract is a collection of code (functions) and data (state) that resides at a specific address in the Ethereum blockchain.

Solidity is a statically typed, high-level language which is influenced by JavaScript, Python, and C++. Solidity supports inheritance, libraries, and user-defined types, and is designed for EVM.

It is recommended to use Remix (https://remix.ethereum.org) for writing smart contracts in solidity. Remix is a browser-based IDE that supports writing, compiling, testing, and deploying solidity smart contracts. Remix provides all of these features in an easy-to-use interface...

In this recipe, you will learn how to test your smart contract using the Remix IDE. Remix is a browser-based IDE that enables users to write Ethereum contracts in the solidity language and debug transactions. Remix has an inbuilt JavaScript-based solidity compiler and EVM to compile and run smart contracts.

1. Open Remix (https://remix.ethereum.org) in your desktop browser.
2. Copy your smart contract to Remix and it will automatically compile your code. Warnings and errors, if any, will be displayed in the right panel.
3. Remix has an inbuilt JavaScript VM for testing smart contracts. Ensure that you have selected JavaScript VM as the default environment under Run:

4. Select an account...

Statically typed programming languages do the type checking at compile time. Since solidity is a statically typed language, the type of each variable has to be specified at compile time. Solidity also provides an option to create complex user-defined types and type conversion.

In this recipe, you will learn about the basic elementary types of solidity, such as int, bool, array, byte, and address.

Remix is the best way to quickly write a test smart contract. Remix is a browser-based IDE that supports writing, compiling, testing, and deploying solidity smart contracts. Remix provides all these features in an easy-to-use interface and can be accessed quickly without any installation...

In this recipe, you will learn about two important methods in a contract: constructor and fallback functions.

The declaration and workings of these methods are very similar to other object-oriented languages. Let's look into each one individually.

The constructor is a function that is executed when a contract is created. It cannot be called explicitly and is invoked only once during its lifetime. Every contract can have exactly one constructor and if no constructor is declared, the contract will use the...

There are several elementary types in solidity that can be used together to form various complex user-defined types. In this recipe, you will learn about two user-defined types in Solidity: struct and enum.

Let's create and work with various user-defined types using struct and enum.

Structs provide a way to define new types of solidity:

1. Use the struct keyword for creating user-defined types in solidity:

struct Person { }

2. Create a struct with a name and the associated properties inside it:

struct Person {
  ...

Most of the control structures from other languages are also supported in solidity. In this recipe, you will learn about supported control structures in solidity, along with examples. The semantics are very similar to C or JavaScript.

1. If-else condition statements are used to perform different actions based on different conditions. Create a function, isValid, which returns true for input values greater than 10 and returns false otherwise:

pragma solidity ^0.4.23;

contract test {
    function isValid(uint input) public pure 
        returns (bool) {
        if (input > 10) {
            return true;
        } else {
            return false;
        }
    }
}

Solidity doesn't support...

A function is a unit of code designed to do a particular task within a larger contract. In this recipe, you will learn about creating and interacting with functions in solidity.

1. Create a function in solidity with the function keyword to perform a specific task. The following example demonstrates how we can create a simple function:

contract Test {
    function functionName() {
        // Do something
    }
}

2. Create another function to accept input parameters. These parameters can be declared just like variables. The following example accepts two parameters of type uint:

contract Test {
    function add(uint _a, uint _b) public {
        // Do something
    }
}

3. Define output parameters...

Arrays and mappings in solidity are the most commonly used data types to store complex data. There are trade-offs in using one over the other, and each has its own advantages. In this recipe, you will learn about common use cases for arrays and mappings.

Arrays and mappings are used for a series of objects, all of which are the same size and type. Arrays store data sequentially with an incrementing index, whereas mappings store data as key-value pairs (which can also be seen as hash tables).

Follow these steps...

Function modifiers are simple snippets that can change the behavior of a contract. In this recipe, you will learn how to create and use function modifiers in solidity.

1. Modifiers are declared with the modifier keyword as follows:

modifier modifierName {
    // modifier definition
}

2. The function body is inserted where the _ symbol appears in the definition of a modifier:

modifier onlyOwner {
    require(msg.sender == owner);
    _;
}

3. Modifiers can accept parameters like functions do. The following example creates a generic modifier to verify the caller address:

contract Test {
    
    address owner;
    
    constructor() public {
        owner = msg.sender;
    }
    
    modifier onlyBy...

Functions and state variables can have visibility modifiers. There are four visibility modifiers in solidity. Functions can be specified as public, private, internal, or external. State variables support all visibility levels except external. In this recipe, you will learn about visibility modifiers and how to use them.

1. If you want the function to be accessible both externally and internally, it has to be marked as public. Public state variables will generate a getter function automatically:

pragma solidity ^0.4.21;
contract Visibility {
    // Public state variables generate an automatic getter
    uint public limit = 110021;

    // Accessible externally and internally...

EVM provides logging facilities through events. When events are called, the arguments that are passed along with them will be stored in the transaction log. This also helps listeners in the distributed application to trigger an action based on a transaction. These logs are associated with the address of the respective contract. The contract itself cannot access any log information stored in the transaction.

In this recipe, you will learn about logging and events, and listening to them from the JavaScript console of geth.

You will need a working installation of geth to test the event listener scripts given in this tutorial. Commands starting with > are executed from the...

There are two types of memory area associated with contracts: storage and memory. Storage is a value store where all contract state variables are stored and are only changed by a transaction. Memory is a temporary storage location that is cleared for each message call. In this recipe, you will learn how to use these types efficiently, based on your requirements.

1. State variables are always stored in storage, and function arguments are always in memory.

2. The memory location of a variable can be explicitly specified with the storage or memory keywords:

uint storage sum;

uint memory calc;

3. Local variables created for struct, array, or mapping types always reference storage...

Solidity is a high-level language and has to be compiled before being deployed to Ethereum. In this recipe, you will learn how to use the solc command-line compiler to compile your smart contract to its binary and ABI.

You need to have a working installation of the solc compiler to step through this recipe. You can also make use of the JavaScript-based solcjs to compile solidity. These commands may not work in solcjs and you have to follow its documentation.

1. Consider the following smart contract...

After writing your smart contract, it is time to deploy it in Ethereum. In this recipe, you will learn about deploying your smart contract and testing it to ensure that it works as intended.

You will need a working installation of the solc compiler to compile your contract and geth to deploy it. We will be using the geth JavaScript console to run the deployment and transaction scripts.

1. Here is our simple smart contract example:

pragma solidity ^0.4.21;

contract HelloWorld {
    
    string public greeting = &quot...