TOTAL: Building an Ethereum Blockchain DApp using Solidity

What is Ethereum and where did it come from? Learn about the history of blockchain technology and how it expanded from a simple cryptocurrency exchange to a robust implementation.

What are some of the best uses for Ethereum? This episode explains how Ethereum works well in the financial industry, like banking and real estate

Another great place for Ethereum application is in digital identity management. People need to be able to interact digitally. That means people need an identity online that can be verified and matched to their real-world identity. Ethereum is a great way to address this issue.

Industries, such as healthcare, energy, and supply chain, are huge and complex. Find out why Ethereum, with its automation and tracking, is an excellent implementation for these.

The government has perhaps the greatest argument for Ethereum application. Ethereum offers transparency, auditability, and reliability that could make a huge difference in paying taxes, tracking government spending, voting, developing policies, and even simple tasks such as using a notary.

Smart contracts are the heart and soul of Ethereum. They are essentially programming code that you write to make Ethereum “do” whatever you want it to do. The smart contracts also enforce the rules required to access the blockchain because they run within the Ethereum Virtual Machine (EVM) that’s required for anyone to download who wants to access the Ethereum blockchain.

Ether (ETH) is Ethereum’s native cryptocurrency. The great thing about Ethereum is that anyone can create a “token” or special cryptocurrency of their own in Ethereum and launch it with an initial coin offering (ICO), similar to how businesses launch with an initial public offering (IPO).

A decentralized autonomous organization (DAO) is one that operates with little to no human interaction. Imagine being able to set up all the rules for a business in smart contracts and run them automatically based on those rules. This could create incredibly efficient businesses and organizations, at least for those that could operate in this way.

The Ethereum ecosystem consists of all the parts required to make the Ethereum blockchain run successfully. This includes the blockchain itself, the Ethereum Virtual Machine (EVM), wallets, and cryptocurrency exchanges. It also includes everything required to create smart contracts, such as development and testing blockchains, a testing framework, and a source code editor or integrated development environment (IDE).

This episode explains how blockchain apps are different than standard apps in ways like decentralized storage and processing, add-only data, and built-in integrity and trust.

This episode discusses the parts of the Ethereum blockchain, which consists of decentralized apps (dApps), blocks, and miners. Each block has transactions which include a digital signature, to and from information, data, and more.

Smart contracts are really the defining feature of Ethereum. This episode discusses what they are and how they establish the rules to access the Ethereum blockchain using the Ethereum Virtual Machine (EVM).

There are several programming languages you can use to write smart contracts. This episode discusses the various languages and their strengths, as well as the most popular language, Solidity.

In order to understand how the Ethereum Virtual Machine (EVM) works, it’s helpful to understand how virtual machines work. If you’re unclear on this topic, check out this helpful episode.

In order to ensure that every node on the blockchain keeps the same copy of the blockchain, and adds the same blocks at the same time, it’s necessary to have some kind of governing entity. This is the job of the Ethereum Virtual Machine (EVM).

It costs a small amount of money, or ether, to access the Ethereum blockchain. Ethereum also uses the idea of gas to limit transactions, protect from denial of service attacks, and ensure concise smart contract language from programmers.

Writing smart contract code is very similar to any other code writing and follows the software development life cycle (SDLC). This episode discusses what the SDLC is as well as the tools you will need to take your Ethereum smart contracts through this process.

A blockchain client is the software that makes a device a node on the Ethereum blockchain and supports the Ethereum standards. This blockchain client also runs the EVM on a node.

This episode discusses some of the tools you’ll need to write and test your smart contract code, including the different types of test blockchains.

This episode discusses the rest of the tool you’ll need to write your smart contract code, including different types of integrated development environments (IDEs) and frameworks.

In order to create smart contracts to deploy to the live Ethereum blockchain, you need several tools. Some are necessary, and some will make it faster and easier to develop your code. These tools include the blockchain client (EVM), and IDE for code development, local and public test blockchains, and the live environment, called mainnet.

This episode walks through the steps to download Go Ethereum (Geth), the command-line interface blockchain client, also known as the Ethereum Virtual Machine. This is the software that makes you an actual node on the Ethereum blockchain.

This episode walks through the steps to download and run Ganache, the test blockchain we’ll be using during this course.

This episode walks through the steps to download and run Truffle, the software program used to simulate a live blockchain environment so you can deploy and test your smart contract code.

This episode walks through the steps to download and install Microsoft Visual Studio Code, a free integrated development environment (IDE) to help you as you develop your smart contract code.

In order to interact with the blockchain, you must create an account to generate a private and public key pair. An Ethereum wallet stores your private keys to keep them safe, since the private key is the only way for you access your cryptoassets stored on the blockchain.

Ethereum wallets come in different types, such as hardware and software, and cold and hot. This episode discusses the different types and their pros and cons.

This episode digs deeper into the web and desktop wallets and gives you a review of some of the popular types.

This episode digs deeper into the mobile, hardware, and paper wallets and gives you a review of some of the popular types.

MetaMask is a simple browser wallet that enables you to interact with public test blockchains and the mainnet. This episode walks through the steps to setting up your own MetaMask account.

It’s time to start setting up your first Truffle project. This episode shows you how to create a new directory for you Truffle project, initialize it, launch Microsoft Visual Studio Code, and configure the Truffle project files.

This episode takes you through some of the basic functions in the programming language, Solidity, including strings, variables, and functions. You will get the chance to practice with every programmer’s first project: the HelloWorld code.

Once you’ve written your simple HelloWorld smart contract, it’s time to compile the source code into something computers understand, bytecode. This episode shows you how to add Solidity plugins into Visual Studio Code and then compile your contract for the Solidity language.

After you’re written and compiled your smart contract code, you need to deploy it to the blockchain for testing. In this episode, you will hook up your development environment to a test blockchain called Ganache and deploy your HelloWorld smart contract to the test blockchain.

Before you dive into the details of smart contracts, this episode gives a brief review of the blockchain and how smart contracts play a crucial role in making the Ethereum blockchain work.

This course is going to take you through an actual project where you will code your very own smart contracts and deploy them to the blockchain. The best way to learn, though, is by using real world examples that help you understand the implications of the technology. This episode describes what the supply chain industry is and gives a few examples of actual blockchain solutions being used today.

There are plenty of issues in supply chain, many of which have been solved or at least mitigated. However, blockchain is the first technology to come around that can solve (nearly) all the issues in a unified way.

This episode digs back into some of the blockchain supply chain examples from a previous episode and discusses more about how they use blockchain technology to solve various issues.

Your supply chain project will have to include a way to pay participants along the supply chain. This episode discusses the payment system in Ethereum: tokens.

Solidity is by far the most popular programming language in Ethereum. This episode talks about the details of the language that will help you as you begin coding your smart contracts.

Handling blockchain data is different than with traditional databases. There are certain considerations you need to keep in mind. This episode discusses the two types of data, local and state variables, and the types of memory, stack, memory, and storage.

Now that you understand Solidity and data types, it’s time to tie your knowledge together by seeing how this works in a real smart contract.

In order to make data accessible to only the people you intend, you’ll need to know certain modifiers, such as whether the data should be public or private, internal or external.

This episode discusses the data modifier, “view”.

This episode goes over a quick review of gas and dives a little deeper into how gas is calculated and used.

Smart contracts are programs made up of functions and data, and any given step might need to branch into several directions, or possibly even go back and be repeated. Controlling flow with “do-while” and “while” loops is important to know for any programmer.

Since everything that gets deployed to the blockchain remains on the blockchain forever, it’s important to work the bugs out first. However, there will always be issues that creep in, and you’ll need to know how to handle errors in Solidity in order to pass on important information for troubleshooting and feedback for the client.

This episode describes the various types of data, token capabilities, and supply chain functions you will need to create your supply chain app project.

Decentralized applications (dApps) are the result of all the smart contract code you write and deploy to the blockchain. This episode details how dApps came about and the advantages to these unique applications.

The payment token smart contract will be the first of 2 smart contracts you will create for this project. This episode discusses all the various data and functions you will be using for this smart contract.

The supply chain smart contract will be the second of 2 smart contracts you will create for this project. Structures

If you’ve gotten a bit confused with all the contracts and data and functions, this episode will help you better understand all the parts and pieces to your supply chain app and the 2 smart contracts you will be writing.

Now that you know the parts of your supply chain app, you’ll need to create and initialize your new project in Truffle. This first part covers how to start your Truffle project, and then discusses the ERC/EIP token standards in Ethereum to make sure your payment token smart contract complies with them.

The second part of the episode discusses interfaces, constructors, functions, and data in the solidity payment token smart contract.

In the first part of this 2-part episode, we will discuss the mapping function for the supply chain smart contract and discuss the various data within in.

The second part of this 2-part episode covers the participant and ownership structures, as well as the mapping function that maps them to different data and variables.

In the first part of this 2-part episode, we will discuss the first 3 functions in the payment token smart contract.

The second part of this 2-part episode covers the last 5 functions in the payment token smart contract.

In the first part of this 2-part episode, we will discuss the first 4 functions in the supply chain smart contract.

The second part of this 2-part episode covers the last 5 functions in the supply chain smart contract.

Smart contract code is essentially server-side code. The smart contract listens for events that the client creates; this means they have to emit an event. In order to implement events in Solidity, you have to define the event, then define a trigger for the event.

This episode goes through the various events in the supply chain and payment token smart contracts and their associated emit functions, which trigger the events.

In blockchain technology, every action has an owner, which is what makes everything that happens on the blockchain auditable. If someone calls a function, their account address is associated to that action. This episode discusses more about ownership, and the common msg.sender value that you’ll see in many places.

Smart contracts need to be secured just like any other type of code. There are some unique considerations for Ethereum smart contracts that you’ll need to keep in mind. This episode discusses the various way you can help ensure security in your smart contract.

A golden standard for developing code is to begin with minimal functionality, then, once the basic functions have been tested and verified, add more functionality after.

There are private (local) and public test blockchains. Both have a reason and purpose in your development lifecycle. Learn about the difference between these two and how to best use their capabilities for your smart contract development.

The live blockchain, also called the live network, main network, or mainnet, is the real deal. You need to be sure you’ve worked out all the bugs you possibly can in your smart contract before deploying to mainnet because 1) it costs a little bit of money to deploy to, and 2) whatever you deploy to mainnet will be there forever and can’t be changed, only updated.

Each public test blockchain, as well as the mainnet, all have unique addresses that you use to connect to them. To connect to each one, you could download each blockchain and become an actual node, or you can use a third-party, like Infura, to connect to them. This episode shows you how to set up and Infura account to access the live blockchain, Ropsten, Rinkeby, and Kovan.

Now that you have an Infura account, you need to configure Truffle to deploy to the public blockchains via this account. This episode shows you how to do this.

In order to interact with public test blockchains or the live blockchain, you need to fund your account with ether (ETH). In the case of test blockchains, you don’t need to use real money, you can just request “fake” ether. When it comes to mainnet, though, you will have to convert some of you own money into ether in order to deploy your smart contracts.

Once you have tested your smart contracts in a testing environment, it’s time to deploy to mainnet. This episode goes over the commands you’ll need to know in order to deploy your code to the live blockchain.