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

The first contract we are writing is the ERC20.sol smart contract. This contract will be inherited by the main token smart contract we will be writing later. For now, this ERC20.sol smart contract will implement the methods specified in the ERC-20 token standard.

To kick things off, create a file in the 

. As we do with all smart contracts, start off by declaring the version of Solidity that we are writing the smart contract with.

In addition to declaring the version of Solidity we will be using, we will also import the interface and libraries that we created in the previous chapter.

pragma solidity ^0.5.0;

import "./interfaces/IERC20.sol";
import "./libraries/Context.sol";
import "./libraries/SafeMath.sol";

Now we need to specify that the contract will inherit from the IERC20 interface and the Context library. Below the imports, let's add the contract declaration:

    contract ERC20 is Context, IERC20 {

    }

Let's revisit the IERC20 interface to help write the required methods and events for this contract. If our contract is not as specified in the IERC20 interface, we will run into errors at compilation.

 smart contract, we will be implementing the methods and events that we said needed to exist using the interface smart contract. In some of the methods we write, we will also trigger the events that we add to this smart contract.

There are a handful of methods we need to implement in the ERC-20 token we are creating, including: 

. There are also two major events that an ERC-20 token needs to capture: 

. We will look at each of these in a bit more detail as we implement them.

Let's add a few variables that will allow us to track this information. Whenever we have 

 variables, we want to use the implementation we specified in 

, and ensure protection from overflow and underflow errors. Inside the contract brackets, add:

Next we will add two mapping variables. Mappings act as hash tables that consist of key types and corresponding value type pairs. To define a mapping, you can write: 

mapping(_KeyType => _ValueType) public mappingName

A more tangible example for our token is to actually keep track of everyone's balances. Let's use a mapping to ensure that information is available. Add the following code to introduce a mapping that tracks balances.

mapping(address => uint256) private _balances;

Another mapping will check how much different users are allowed to send for the token we are creating. ERC-20 tokens should only be spent by the owners of the token. However, since Ethereum is a world of smart contracts, we may need to delegate the "spending" ability to a smart contract address.

To keep track of allowances, add the following code:

mapping(address => mapping(address => uint256)) private _allowances;

Here we created a mapping inside a mapping because we want to check if the user has delegated spending ability to anyone else and by how much.

 - it will keep track of how many tokens we have in circulation. Simply add:

We kept these variables private, but now we will be writing public methods for the 

 smart contract so that people can use the information we are capturing for the token.

 smart contract. It will be called whenever tokens are transferred from one address to another. Since we declared the event in the 

 interface, we don't need to add a new declaration for the event here, but simply call 

This is another event, which will be called whenever the approval amount of an address (ie how much it can spend) is updated. Again, as the event is declared in the interface, we don't need to declare it here and just call 

Now - let's look at the methods we need to add to the 

---
title: "Smart Contract for ERC-20 Tokens"
# description: 
# privateVideoUrl: 
---

# Smart Contract for ERC-20 Tokens

The first contract we are writing is the ERC20.sol smart contract. This contract will be inherited by the main token smart contract we will be writing later. For now, this ERC20.sol smart contract will implement the methods specified in the ERC-20 token standard.

### ERC20.sol

To kick things off, create a file in the `contracts` folder and name it `ERC20.sol`. As we do with all smart contracts, start off by declaring the version of Solidity that we are writing the smart contract with.

In addition to declaring the version of Solidity we will be using, we will also import the interface and libraries that we created in the previous chapter.

    pragma solidity ^0.5.0;

    import "./interfaces/IERC20.sol";
    import "./libraries/Context.sol";
    import "./libraries/SafeMath.sol";

Now we need to specify that the contract will inherit from the IERC20 interface and the Context library. Below the imports, let's add the contract declaration:

        contract ERC20 is Context, IERC20 {

        }

Let's revisit the IERC20 interface to help write the required methods and events for this contract. If our contract is not as specified in the IERC20 interface, we will run into errors at compilation.

In this `ERC20.sol` smart contract, we will be implementing the methods and events that we said needed to exist using the interface smart contract. In some of the methods we write, we will also trigger the events that we add to this smart contract.

There are a handful of methods we need to implement in the ERC-20 token we are creating, including: `totalSupply`, `balanceOf`, `transfer`, `allowance`, `approve` and `transferFrom`. There are also two major events that an ERC-20 token needs to capture: `Transfer` and `Approval`. We will look at each of these in a bit more detail as we implement them.

Let's add a few variables that will allow us to track this information. Whenever we have `uint256` variables, we want to use the implementation we specified in `SafeMath`, and ensure protection from overflow and underflow errors. Inside the contract brackets, add:

    using SafeMath for uint256;

Next we will add two mapping variables. Mappings act as hash tables that consist of key types and corresponding value type pairs. To define a mapping, you can write: `mapping(_KeyType => _ValueType) public mappingName`.

A more tangible example for our token is to actually keep track of everyone's balances. Let's use a mapping to ensure that information is available. Add the following code to introduce a mapping that tracks balances.

    mapping(address => uint256) private _balances;

Another mapping will check how much different users are allowed to send for the token we are creating. ERC-20 tokens should only be spent by the owners of the token. However, since Ethereum is a world of smart contracts, we may need to delegate the "spending" ability to a smart contract address.

To keep track of allowances, add the following code:

    mapping(address => mapping(address => uint256)) private _allowances;

Here we created a mapping inside a mapping because we want to check if the user has delegated spending ability to anyone else and by how much.

The last variable we will add is `total supply` - it will keep track of how many tokens we have in circulation. Simply add:

    uint private _totalSupply;

We kept these variables private, but now we will be writing public methods for the `ERC20.sol` smart contract so that people can use the information we are capturing for the token.

#### Transfer Event

This is an event for the `ERC20.sol` smart contract. It will be called whenever tokens are transferred from one address to another. Since we declared the event in the `IERC20.sol` interface, we don't need to add a new declaration for the event here, but simply call `emit Transfer(sender, recipient, amount)` whenever we need it.

#### Approval Event

This is another event, which will be called whenever the approval amount of an address (ie how much it can spend) is updated. Again, as the event is declared in the interface, we don't need to declare it here and just call `emit Approval(owner, spender, amount)` whenever we need it.

Now - let's look at the methods we need to add to the `ERC20.sol` smart contract:

#### totalSupply Method

Add this method to the contract `ERC20.sol`. It will just return the `_totalSupply` variable we added.

        function totalSupply() public view returns (uint256) {
            return _totalSupply;
        }

A few things to note:

-   the method is **public** and **view** only
-   the method returns a uint256 value (the same value as the `_totalSupply` variable we declared above)
-   the name of the method _must_ match the name of the method in `IERC20.sol`. (This will be the case for the next set of methods and events we create)

#### balanceOf Method

This public method gets information from our private mapping. To get the balance of a specific address, we can also add an input variable. Add this method to `ERC20.sol`:

        function balanceOf(address account) public view returns (uint256) {
            return _balances[account];
        }

Note the way we access mappings in Solidity methods. Though it is a hash object, we follow this convention: `mappingName[_key];`

#### transfer Method

We need to create two methods to implement this properly, one public and another internal.

The internal method will take in three variables and carry out a few checks.

Variables:

-   `sender` (will be an `address`)
-   `recipient` (will be an `address`)
-   `amount` (will be a `uint256`)

Checks:

-   ensure that the sender and receiver are not a zero address. The zero address on the Ethereum blockchain (i.e. 0x0000000000000000000000000000000000000000). No one has access to the zero address. If the zero address is interacting with your smart contracts, it means that something is very wrong.


        function _transfer(
            address sender,
            address recipient,
            uint256 amount
        ) internal {
            require(sender != address(0), "ERC20: transfer from the zero address");
            require(recipient != address(0), "ERC20: transfer to the zero address");