Creating Smart Contracts with Ethereum

We already compiled a Solidity program in Section 1. We know what it does, but we don't yet know what the code means. In this lesson, we'll learn to understand the contract we deployed in Section 1 by examining each line of the program carefully.

• Understand `pragma solidity ^x.x.x` declarations and Solidity versioning

• Understand the Mortal contract

• Understand the Greeter contract

Why does the most recent version of Solidity throw warnings when we try to compile the smart contract from last video? How can I deploy this code with the warnings removed? We'll take a hands-on approach to answering these questions by debugging the warning messages and updating our code to be Solidity ^0.4.25 friendly.

• Understand Solidity constructor statements

• Understand Solidity visibility requirements for variable types and functions

• Understand static analysis warnings

Understanding how to call smart contracts from a web application environment, and just from within the Remix console, is important if we want to build Ethereum applications. In this video we will learn how to query the Ethereum blockchain from our own JavaScript environment.

• Query open permissions endpoints from Infura

• Set up a Web3 JavaScript with npm and Node.js

• Connect Web3 with an Infura provider

Once we have configured Web3 to work with Infura, we'll need to learn how to connect our Web3 instance with an instance of our contract. In this video, we'll learn how to connect our Infura provider instance of Web3 with a contract instance and how to query the contract's functions using Web3.

• Understand the ABI or Application Binary Interface

• Connect Web3 with an instance of our smart contract

• Call our deployed contract using Web3

Now that we're competent at compiling and deploying basic smart contracts, we need to take a deeper look at what interacting with complex contracts entails.

• Understand what the open auction contract will do

• Compile and deploy the contract

• Call the bid function by bootstrapping the contract in MyEtherWallet

Now that we understand the contract's basics and how to load and call it, we finish analyzing the contract by calling all its functions and investigate sending invalid data to the bid function.

• Investigate how the smart contract handles a bid sent to it with invalid parameters

• Call the withdraw function to return losing bids to the sender

• Call the auctionEnd function and closing the auction

In order to program complex smart contracts, we need to know about all of the data and reference types available to developers, which are explained in detail in this video.

• Understand function declarations and how Solidity functions can differ from other programming languages

• Understand value type variables in Solidity and how to declare and implement them

• Understand reference type variables in Solidity and how to declare and implement them

We already have a basic understanding of value and reference type variables, but this video provides an in depth lesson on utilizing two key variable types which are more specific to Ethereum development, and which may be new concepts for developers.

• Understand how mappings work in Solidity

• Understand and making use of structs

• Investigate using a struct in a real DApp which is served online

Although type modifiers are common to many programming languages, function modifiers are specific to Ethereum. In this video we learn what function modifiers are and how to use them.

• Understand what function modifiers are and also how they can be overridden

• How to declare and implement function modifiers

• Call a modifier from a deployed smart contract using Remix

We've already covered a lot of concepts in advanced smart contract programming. This lesson will complete any knowledge about Solidity syntax and available commands which haven't yet been covered.

• Understand returning output from a smart contract

• Use assertions in Solidity to handle errors and exceptions

• Emit events and how they can be listened for by a DApp frontend

We've already learned how to create, compile and deploy smart contracts, but we haven't yet learned how to interact with them from an ender user perspective. In this video, we'll learn how to build web application that calls our Solidity code in a way fit for public consumption.

• Learn about the smart contract powering our web application

• Compile and deploy the contract

• Decide on, and listing, our DApp's dependencies

Before we can call our smart contract code from a web browser, we need to create our web application environment and connect with with Web3. In this video, we'll learn the step by step process of how to achieve this with the React.js framework.

• Install our dependencies and running a web server

• Brainstorming creating our MetaMask user workflow

• Program our web application and incorporating that user workflow

We've already created a Web3 enabled web application, but we need to connect our smart contract and interact with it as an end user. In this video, we'll learn all about connecting to a smart contract and calling its functions.

• Update our main application file (app.js) and listening for emitted events

• Import the ABI and connecting Web3 with our smart contract

• Update our Redux reducers and calling smart contract functions from React

A lot of code has been written and our game DApp is finally ready to be played by others. In this video we take a hands-on approach to interacting with our DApp from the UI.

• Review our old deployment

• Review the final version of our DApp

• Review the source code implemented in the final version

Before our decentralized application is ready to be deployed on the Ethereum mainnet we need to assemble a unit testing environment, and test the security of our smart contract. In this video we'll learn how to begin this process.

• Explore our project layout, the Truffle framework, and its modules

• Install and configure Truffle

• Connect Truffle to our DApp's smart contract

Now that we have configured a unit testing environment for Solidity we can start to run unit tests against our DApp's smart contract, as demonstrated in this video.

• Create and run a simple unit test

• Add more complexity to our unit test

• Finalize and run our complex unit test

If we want users of our DApp to be able to trust that the smart contract they are sending money too isn't doing something suspicious, we're going to need to publish verified Solidity files for them to browse online. This video demonstrates how to do that on Etherscan.io, the most popular Ethereum transaction browser.

• Learn why verifying and publishing Solidity source code online is important

• Upload and verify the source code for our DApp

• Browse the published source code on Etherscan

In the same way that the Internet DNS system provides human readable addresses to resolve IP addresses, the Ethereum network has the ENS system to provide human readable names for wallet and smart contract addresses. In this video we cover the steps required for registering an ENS name with the Ethereum Name Service registrar.

• Learn about ENS

• Open an ENS auction

• Reveal our bids during the bid phase, to validate them