The Ethereum blockchain has been described as the driving force behind the next generation of the internet. The blockchain has built-in smart contract capabilities, a large developer community, and its own native cryptocurrency. In this section we will learn about how the book is structured and get you equipped with the tools you'll need to start writing your own blockchain and smart contracts.

This Book's Mission

What Do I Need to Know?

Understanding Ethereum and Blockchain Use Cases

What Makes Ethereum?

Key Technologies and Other Considerations

This section borrows code and code examples from throughout the internet to explain some of the key concepts of blockchain and Solidity development. The code has been commented on, explained, and updated as needed. Special thanks to these authors for helping the blockchain community more approachable through the code and blogs that they created - [StephenGrider](https://github.com/StephenGrider/EthereumCasts), [Savjee](https://www.savjee.be/2017/07/Writing-tiny-blockchain-in-JavaScript/), [Xavier Decuyper](https://www.codementor.io/@savjee/how-to-build-a-blockchain-with-javascript-part-1-k7d373dtk), and [Alibaba Cloud](https://www.alibabacloud.com/blog/build-your-own-blockchain-with-javascript_595314) - thank you for the inspiration!

What's in This Book?

How Should I Read This Book?

Getting Help

Let's Get Started!

Introduction

Before we dive into the Ethereum blockchain and start writing smart contracts, let's explore what a blockchain actually is. This chapter will jump into some of the fundamentals and give you a practical understanding of what blockchains are. This section will walk you through a coding exercise that will enable you to write a blockchain from scratch.

Basics of Blockchain

Smart Contract Development - Setting Up Your Environment

Understanding blockchain fundamentals

Getting Familiar with Blockchain

Now that we understand how blockchains work, let's dive into the Ethereum blockchain. There are various concepts from the protocol itself, how accounts work and the blockchain's underlying cryptocurrency which can be tricky to understand. This chapter will explore the Ethereum blockchain in detail and help you get comfortable with some of the basics.

Section Introduction

Proof of work (PoW) is a form of cryptographic zero-knowledge proof in which one party (the prover) proves to others (the verifiers) that a certain amount of computational effort has been expended for some purpose. Verifiers can subsequently confirm this expenditure with minimal effort on their part. [Source](https://en.wikipedia.org/wiki/Proof_of_work)

What is Ethereum

Ether and Gas

What comes after the Ethereum blockchain?

Ethereum Blockchain

Basics of Cryptocurrencies

Ethereum Smart Contracts - A Brief Overview

Basics of Tokens

DAI is a stable coin that is backed by the ether cryptocurrency. It also has a set of smart contracts that allow people to lock their ether and create stablecoins called Dai. The Dai token has a price target of $1 USD and allows people to trade between other cryptocurrencies without worrying about volatility.

Token Standards

What is Decentralized Finance?

Ready to jump into smart contracts?

Cryptocurrencies on Ethereum

Smart contracts can be used to create anything on the Ethereum blockchain. Developers can write software, cryptocurrencies, or anything that their mind imagines. This section will introduce the Solidity programming language and enable the reader to start writing their first smart contract.

Writing a Simple Smart Contract

What is Remix IDE and What Can it Do?

How crazy can smart contracts get?!

Smart contracts can be used to design any type of software, including games. In this chapter, we will continue building on our Solidity skills by writing a smart contract game. Some of the key concepts introduced in this chapter will include payable functions and function modifiers.

An Introduction to Creating a Solidity Smart Contract Game

Designing the Money Game Smart Contract

Working with contract intializers

Getting users to use crypto with smart contracts

Writing a Function to Read the Target Number

Compile and Deploy Smart Contracts with JavaScript VM

Using the Deployed Smart Contract in Remix

Thank you again to [StephenGrider](https://github.com/StephenGrider/EthereumCasts). Both the Inbox.sol and Lottery.sol contracts were excellent inspirations for the Money Game smart contract. They explain a lot of the key concepts in Solidity programming.

Play games... win money!

Diving Deeper Into Smart Contracts

One of the most popular uses of smart contracts is to create ERC-20 tokens. In this chapter, we will learn about the ERC-20 token standard and start writing some of the smart contracts required to create the ERC-20 token for the Ethereum blockchain.

Creating a Token Smart Contracts for the Blockchain Part 1

Fungible vs Non Fungible Tokens: How do They Work?

Writing Smart Contracts for Fungible Tokens

Smart Contract Development on a Local Machine

Understanding the Truffle Suite - Ganache and Truffle

Smart Contracts Interfaces - How do They Work?

Smart Contract Libraries

Token foundation is now ready

In this chapter, we will continue writing the ERC-20 token smart contracts. We will learn about how smart contracts follow object oriented programming by importing contracts we created in the previous chapter into the smart contracts we will be writing in this chapter. In this chapter, we will have the basic ERC-20 token implemented with Solidity.

Creating a Token Smart Contracts for the Blockchain Part 2

Smart Contract for ERC-20 Tokens

Token (almost) ready!

Now that we have the basic implementation of the ERC-20 token created, let's create a few smart contracts that we can use to add more functionality to the token smart contract we will be creating. At the end of this chapter, we will be ready to compile and deploy our token smart contract.

Creating a Token Smart Contracts for the Blockchain Part 3

Token complete!

Since our main token smart contract has several different smart contracts involved, in this chapter, we will use a tool called Truffle to simplify smart contract compilation and deployment. At the end of this chapter, we will use Truffle and another tool called Infura to send our token smart contract to a public Ethereum test network.

Compiling and Deploying the ERC-20 Smart Contract

Run a Local Blockchain with Truffle and Ganache

Configuring Truffle

How to Compile Smart Contracts Using Truffle

Use Truffle to Deploy a Smart Contract on a Local Blockchain

Create an Infura Account For API Access to the Ethereum Blockchain

How to Use the Truffle Migrate Script for Contract Deployments

Tokens awayyyy (on the Ethereum blockchain)

Conclusion

Appendix

Changelog

node.js

solidity

In this course, we'll create an ERC-20 standard compliant token and send it to an public Ethereum test network (which isn't very different from sending it to the main Ethereum network).

Before we jump into that, we will learn what blockchains are, how the Ethereum blockchain works, and the start diving into smart contract development with Solidity. 

The examples we'll work with in the book with will start off simple and then we will progressively work our way up to writing all the smart contracts required to create an ERC-20 token on the Ethereum blockchain.

After we write the smart contracts, we'll also get familiar with tools like Remix and Truffle so that we can compile our code and deploy it to the blockchain together. 

We will work with local, test, and public blockchains so that you understand the differences between each one.

This course is 9 chapters of detailed content which is designed to give you everything you need to kick off your journey as a smart contract developer.

Along the way, we'll learn the following: 

* How blockchains worth through a practical implementation of one with JavaScript 
* How the Ethereum blockchain works and what makes it popular (i.e. smart contracts)
* How to write simple Solidity smart contracts
* How to write complex Soldity smart contracts that handle cryptocurrencies
* How to compile and deploy Solidity smart contracts with Remix
* How to write advanced Solidity smart contracts that can be used to create tokens on the Ethereum blockchain
* How to compile and deploy the token smart contracts using popular blockchain development tools like Truffle and Infura

By the end of this course you will understand how blockchains work, what the Ethereum blockchain is and what are the major use cases that are being worked on in that ecosystem. Once you get familiar with that, you will also be equipped with tactical and tangile skills to start writing smart contracts for the Ethereum blockchain.

This project introduces the fundamentals of blockchain, what the Ethereum blockchain is, and how to write smart contracts for the Ethereum blockchain.

Creating an ERC20 Token on Ethereum

How to write your own blockchain in JavaScript

How to write smart contracts for the Ethereum blockchain

How to use Remix to compile and deploy your Ethereum smart contracts

How to use smart contracts to create tokens on the Ethereum blockchain

How to use Truffle to compile and deploy your token smart contracts

Remix is a browser-based integrated development environment that allows users to write smart contracts in Solidity and Vyper. For this course, we will be writing all of our smart contracts in Solidity.

Once the smart contracts are ready for the Ethereum blockchain, there are a variety of different tools to allow us to deploy and run them. We can deploy on a local blockchain, a test blockchain, or on the main Ethereum blockchain. As we progress through this chapter, we will explain what each means.

. It is important to take note of which you select, because to send our smart contract to the blockchain, there are certain limitations if we access Remix through the secure protocol 

. For the following few sections, I will be using the 

From this page, we will select "Solidity" as the environment we want to use.

Upon selecting the "Solidity" environment, the "Solidity Compiler" will appear on the left. We can specify a few parameters here so that we are all aligned. Solidity is a tricky language because it evolves quite frequently, so pay close attention to the configuration we are applying here.

In the Solidity Compiler panel on the left, we're going to specify our compiler, to process the smart contract that we write.

The compiler can produce various outputs, ranging from simple binaries and assembly over an abstract syntax tree (parse tree) to estimations of gas usage. These outputs can be used in web applications that interact with the smart contract once we are done deploying it to the blockchain.

Once these values are selected, your Solidity compiler settings should look like this:

 to write the smart contracts for this book.

Now that we've added the appropriate compiler settings, let's jump into the File Explorer. You will notice that there is a toolbar on the left of your Remix screen.

From this toolbar, you can get to the file explorer by clicking the following button:

This will show the following next to the toolbar:

The files that you see may be different from what is shown in the book because this is your first time using 

From this section, we can do five things:

For the purposes of this chapter, we will only be viewing the files we want to work with and creating a handful of files to write smart contracts in.

This will prompt you to add a file name for the smart contract that you are creating.

We will call this file "Inbox.sol". Once we put in the name, let's close the popup -the file should already be open in Remix. The file is blank, and we are now ready to start writing some Solidity.

. The Inbox.sol is a common smart contract example to identify how to read and write to a blockchain through a smart contract. Minor updates have been made to the code to align with a newer version of Solidity.

Now that we have our smart contract file created, let's start adding some code.

The first thing that you have to do is to identify which version of Solidity you are using. We selected version ^0.6.12. The 

 is the minimum version of Solidity we want to use. To ensure that the Solidity processor knows what version we are using, we have to start the file by declaring that:

The next line of code declares the contract. In Solidity, use the keyword 

 followed by the name of the contract. The contents of the contract will be contained within curly braces 

The purpose of this smart contract is to store a simple message on the blockchain. The message will be of type 

 and will be publicly available. This means that if anyone can find this contract on the blockchain, the message that is stored will be readable to that user.

To declare a public variable within the smart contract, add the following code inside the contract brackets:

contract Inbox {
    string public message;
}

The first keyword is the type of variable we want to create, the second keyword is to identify to the Solidity processor that this variable should be publicly available, and the final word is the name of the variable, 

Since this line of code is not a function (or a modifier... more on that later), the line must end with a semicolon (

Now that we have our variable out of the way, the next thing is to create a constructor function. In Solidity, like other programming languages:

To declare a constructor in Solidity, use the keyword 

. Next you have to identify if this function takes any inputs. In our case, our constructor will take a string variable which will be used to update the 

 variable that we just created. Finally specify the constructor's visibility. Let's keep it 

. Once this is complete, add curly braces (the rest of our code will reside within these).

constructor(string memory _message) public {
    
}

A few notes here about syntax and styling:

In this constructor, we will be updating the 

 variable with the string that we are passing into the constructor. Inside the constructor, let's set the 

One other thing we might want to do with this smart contract is have the ability to change messages once the contract is available on the blockchain. When the smart contract is initially deployed, the state of the Ethereum blockchain gets updated with the message that we initially set. Since we are creating a smart contract called "Inbox", one of the things we may want to do is update the message that is stored at this smart contract. The variable, 

To do this, we will add a function called 

. This function will take in a string variable called 

To declare a function in Solidity, use the 

 keyword and then name the function. Once the function is declared, add the variables you will pass in and the visibility. It should look something like this:

function changeMessage(string memory _changeMessage) public {

}

---
title: "What is Remix IDE and What Can it Do?"
# description: 
# privateVideoUrl: 
---

# Remix IDE

Remix is a browser-based integrated development environment that allows users to write smart contracts in Solidity and Vyper. For this course, we will be writing all of our smart contracts in Solidity.

Once the smart contracts are ready for the Ethereum blockchain, there are a variety of different tools to allow us to deploy and run them. We can deploy on a local blockchain, a test blockchain, or on the main Ethereum blockchain. As we progress through this chapter, we will explain what each means.

### Getting Started with Remix

`Remix` can be found at `http://remix.ethereum.org/`, or a secure version at `https://remix.ethereum.org`. It is important to take note of which you select, because to send our smart contract to the blockchain, there are certain limitations if we access Remix through the secure protocol `https`. For the following few sections, I will be using the `http` version of `Remix`.

We will see the following screen:

![remix-1](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-1.png)

From this page, we will select "Solidity" as the environment we want to use.

![remix-2](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-2.png)

Upon selecting the "Solidity" environment, the "Solidity Compiler" will appear on the left. We can specify a few parameters here so that we are all aligned. Solidity is a tricky language because it evolves quite frequently, so pay close attention to the configuration we are applying here.

### Compiler

In the Solidity Compiler panel on the left, we're going to specify our compiler, to process the smart contract that we write.

The compiler can produce various outputs, ranging from simple binaries and assembly over an abstract syntax tree (parse tree) to estimations of gas usage. These outputs can be used in web applications that interact with the smart contract once we are done deploying it to the blockchain.

Configure the compiler as follows:

-   Compiler: v0.6.12
-   Language: Solidity
-   EVM Version: Compiler Default
-   Auto Compile: Flag Selected
-   Enable optimization: Flag Selected and number set to 200

Once these values are selected, your Solidity compiler settings should look like this:

![remix-4](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-4-new.png)

We will be using Solidity version `0.6.12` to write the smart contracts for this book.

### File Explorer

Now that we've added the appropriate compiler settings, let's jump into the File Explorer. You will notice that there is a toolbar on the left of your Remix screen.

![remix-5](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-5.png)

From this toolbar, you can get to the file explorer by clicking the following button:

![remix-6](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-6.png)

This will show the following next to the toolbar:

![remix-7](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-7.png)

The files that you see may be different from what is shown in the book because this is your first time using `Remix`.

From this section, we can do five things:

1.  View the smart contracts that we've created (if this is your first time, you may see two files already available)
2.  Create a new file
3.  Publish the files that you have on GitHub as a gist
4.  Copy all files into another version of Remix
5.  Add local storage to the file explorer

For the purposes of this chapter, we will only be viewing the files we want to work with and creating a handful of files to write smart contracts in.

Let's click the `+` icon to add our first contract.

This will prompt you to add a file name for the smart contract that you are creating.

![remix-9](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-9.png)

We will call this file "Inbox.sol". Once we put in the name, let's close the popup -the file should already be open in Remix. The file is blank, and we are now ready to start writing some Solidity.

![remix-10](https://d2uusema5elisf.cloudfront.net/courses/creating-an-erc20-token-on-ethereum/module_04/lesson_04.02/public/images/4-writing-a-simple-smart-contract/remix-10.png)

### Creating a Smart Contract with Remix

> The following code was inspired by [StephenGrider](https://github.com/StephenGrider/EthereumCasts). The Inbox.sol is a common smart contract example to identify how to read and write to a blockchain through a smart contract. Minor updates have been made to the code to align with a newer version of Solidity.

#### Initial Set-Up

Now that we have our smart contract file created, let's start adding some code.

The first thing that you have to do is to identify which version of Solidity you are using. We selected version ^0.6.12. The `^` lets the compiler know that the `0.6.12` is the minimum version of Solidity we want to use. To ensure that the Solidity processor knows what version we are using, we have to start the file by declaring that:

```solidity { actualFilename=./protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol endLine=18 startLine=17 statedFilename=4-writing-a-simple-smart-contract/Inbox.sol url=https&#x3A;//gitlab.com/fullstackio/books/fullstack-ethereum/module_04/lesson_04.02/protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol#L17 }
pragma solidity ^0.6.2;
```

The next line of code declares the contract. In Solidity, use the keyword `contract` followed by the name of the contract. The contents of the contract will be contained within curly braces `{}`.

```solidity { actualFilename=./protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol endLine=22 startLine=19 statedFilename=4-writing-a-simple-smart-contract/Inbox.sol url=https&#x3A;//gitlab.com/fullstackio/books/fullstack-ethereum/module_04/lesson_04.02/protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol#L19 }
contract Inbox {

}
```

The purpose of this smart contract is to store a simple message on the blockchain. The message will be of type `string` and will be publicly available. This means that if anyone can find this contract on the blockchain, the message that is stored will be readable to that user.

To declare a public variable within the smart contract, add the following code inside the contract brackets:

    contract Inbox {
        string public message;
    }

The first keyword is the type of variable we want to create, the second keyword is to identify to the Solidity processor that this variable should be publicly available, and the final word is the name of the variable, `message`.

Since this line of code is not a function (or a modifier... more on that later), the line must end with a semicolon (`;`).

Now that we have our variable out of the way, the next thing is to create a constructor function. In Solidity, like other programming languages:

-   **functions** are modules of code that accomplish a specific task. They take in data, process it, and return a result.
-   **constructors** are special functions that are executed when the smart contract is initially created.

To declare a constructor in Solidity, use the keyword `constructor`. Next you have to identify if this function takes any inputs. In our case, our constructor will take a string variable which will be used to update the `message` variable that we just created. Finally specify the constructor's visibility. Let's keep it `public`. Once this is complete, add curly braces (the rest of our code will reside within these).

```solidity { actualFilename=./protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol endLine=28 startLine=25 statedFilename=4-writing-a-simple-smart-contract/Inbox.sol url=https&#x3A;//gitlab.com/fullstackio/books/fullstack-ethereum/module_04/lesson_04.02/protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol#L25 }
constructor(string memory _message) public {
    
}
```

A few notes here about syntax and styling:

1.  There are two keywords associated with `string` variables in Solidity: `storage` and `memory`. If you anticipate creating functions that make state changes, `storage` might be the best option. If you need a copy of the data but don't necessarily want to manipulate the contract state use `memory`. When passing in `string` variables into functions, they should be passed in with the `memory` keyword.
2.  If you are passing in variables, a styling suggestion is to prefix your variable name with an underscore (`_`).

In this constructor, we will be updating the `message` variable with the string that we are passing into the constructor. Inside the constructor, let's set the `message` of the smart contract to the `_message` variable we are passing in.

```solidity { actualFilename=./protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol endLine=30 startLine=29 statedFilename=4-writing-a-simple-smart-contract/Inbox.sol url=https&#x3A;//gitlab.com/fullstackio/books/fullstack-ethereum/module_04/lesson_04.02/protected/code/src/4-writing-a-simple-smart-contract/Inbox.sol#L29 }
message = _message;
```

#### Adding More Functions

One other thing we might want to do with this smart contract is have the ability to change messages once the contract is available on the blockchain. When the smart contract is initially deployed, the state of the Ethereum blockchain gets updated with the message that we initially set. Since we are creating a smart contract called "Inbox", one of the things we may want to do is update the message that is stored at this smart contract. The variable, `message`, will get updated.

To do this, we will add a function called `changeMessage`. This function will take in a string variable called `_changeMessage` and it will be publicly accessible.

To declare a function in Solidity, use the `function` keyword and then name the function. Once the function is declared, add the variables you will pass in and the visibility. It should look something like this: