Course Outline
Learn Go and Solidity concepts by building three smart contracts with increasing levels of complexity. Learn how to write smart contracts in Solidity and leverage the Go programming language to deploy, test, and interact with those contracts. The class will run a local Ethereum node in dev mode, but the class will also show how to deploy the contract to a TestNet.
This class is perfect for any Go developer wanting to better understand Ethereum and how smart contracts work.
- Writing and deploying a simple smart contract to learn the basics.
- Writing a more complex smart contract to learn more of the language.
- Writing a proxy based smart contract to learn how to handle code changes.
- Writing a contract that can verify Ethereum digital signatures.
- Put it all together with a production level contract, business package, and tests.
- Learn the cost of API design and what you need to think about when building dApps.
- Learn idioms and code style for the Solidity programming language.
- Running a local version of Ethereum for development.
- Deploying and executing smart contracts on a TestNet.
For further class information, please see the Class Schedule
Introduction to the class and all the engineering that you will learn.
- 1.1: Design Philosophy, Guidelines, What to Expect
- 1.2: Tooling to Install
- 1.3: Initial Code for the Project
An understanding of what a smart contract is and what is needed to write code.
- 2.1: Smart Contract Fundamentals
- 2.2: Understanding the deployment process
- 2.3: Understanding the costs
- 2.3: Development Environment
- 2.4: Running the Development Environment
We start with writing a basic smart contract, deploying the contract, and interacting with it using Go.
- 3.1: Writing the Contract
- 3.2: Building the Contract
- 3.3: Writing the Go Deployment Program
- 3.4: Writing a Go Program to Access the Smart Contract API
We write a more complex smart contract to showcase more of the Solidity language.
- 4.1: Writing the Contract
- 4.2: Thinking about the cost of the API design
- 4.3: Building the Contract
- 4.4: Writing the Go Deployment Program
- 4.5: Writing a Go Program to Access the Smart Contract API
We write a production level smart contract used in the Liar's Dice game.
- 5.1: Writing the Contract
- 5.2: Thinking about the cost of the API design
- 5.3: Building the Contract
- 5.4: Writing the Go Deployment Program
- 5.5: Writing a Go Program to Access the Smart Contract API
We implement the proxy pattern for the bank smart contract.
- 6.1: What is the proxy pattern
- 6.2: Writing the Contract
- 6.3: Thinking about the cost of the API design
- 6.4: Building the Contract
- 6.5: Writing the Go Deployment Program
- 6.6: Writing a Go Program to Access the Smart Contract API
We implement a smart contract that can receive a digital signature and verify it.
- 7.1: What is a digital signature
- 7.2: Writing the Contract
- 7.3: Thinking about the cost of the API design
- 7.4: Building the Contract
- 7.5: Writing the Go Deployment Program
- 7.6: Writing a Go Program to Access the Smart Contract API
We implement a production level contract with business package and tests.
- 8.1: Writing the Contract
- 8.2: Writing the business package
- 8.3: Writing the business package tests
- 9.1: Using a faucet to add money to your address
- 9.2: Accessing a TestNet using Infura
- 9.3: Deploying, testing, and interacting