Solidity Programming Essentials: A guide to building smart contracts and tokens using the widely used Solidity language

Cover
Title Page
Contributors
Table of Contents
Preface
Copyright and Credits
Part 1: The Fundamentals of Solidity and Ethereum
Chapter 1: ockchain, Ethereum, and Smart Contracts
	Technical requirements
	What is a blockchain?
	The need for blockchain
	Understanding cryptography
		Hashing
		Digital signatures
		Reviewing blockchain and Ethereum architecture
		Relationship between blocks
		How transactions and blocks are related to each other
	Consensus
		Proof of work
		Proof of stake
	Ethereum nodes
		EVM
		Mining nodes
		Ethereum validators
	Ethereum accounts
		Externally owned accounts
		Contract accounts
		Ether, gas, and transactions
	Blocks
	An end-to-end transaction
	Smart contract
		Writing smart contracts
	The internals of smart contract deployment
	Summary
	Questions
	Further reading
Chapter 2: Installing Ethereum and Solidity
	Technical requirements
	Ethereum networks
		Main network
		Test network
		Private network
		Consortium network
	Installing and configuring Geth
		Installing Geth on macOS
		Installing Geth on Windows
	Creating a private network
	Installing Ganache
	Installing the Solidity compiler
	Installing the web3 framework
	Installing and using MetaMask
	Summary
	Questions
	Further reading
Chapter 3: Introducing Solidity
	Technical requirements
	The Ethereum Virtual Machine
	Understanding Solidity and Solidity files
		Pragma
		Comments
		Importing Solidity code
		Contracts
	The structure of a contract
		State variables
		Structure
		Modifiers
		Events
		Enumeration
		Functions
	Exploring data types in Solidity
		Value types
		Reference types
	Storage and memory data locations
		Rule one
		Rule two
		Rule three
		Rule four
		Rule five
		Rule six
		Rule seven
		Rule eight
	Using literals
	Understanding integers
	Understanding Boolean
	The byte data type
	Understanding arrays
		Fixed arrays
		Dynamic arrays
		Special arrays
		Array properties
	Knowing more about the structure of an array
	Enumerations
	Understanding the address data type
	Working with mappings
	Summary
	Questions
	Further reading
Chapter 4: Global Variables and Functions
	Technical requirements
	Variable scoping
	Type conversion
		Implicit conversion
		Explicit conversion
	Block and transaction global variables
		Transaction- and message-related global variables
		The difference between tx.origin and msg.sender
	Cryptographic global variables
	Address global variables
	Contract global variables
	Recovering addresses using ecrecover
	Summary
	Questions
	Further reading
Chapter 5: Expressions and Control Structures
	Technical requirements
	Understanding Solidity expressions
	Understanding the if and if...else decision control
	Exploring while loops
	Understanding the do...while loop
	Understanding breaks
	Understanding continue
	Understanding return
	Summary
	Questions
	Further reading
Part 2: Writing Robust Smart Contracts
Chapter 6: Writing Smart Contracts
	Technical requirements
	Smart contracts
	Writing a smart contract
	Creating contracts
		Using the new keyword
		Using the address of a contract
	Contract constructor
	Contract composition
	Inheritance
		Single inheritance
		Multilevel inheritance
		Hierarchical inheritance
		Multiple inheritance
	Encapsulation
	Polymorphism
		Function polymorphism
		Contract polymorphism
	Method overriding
	Abstract contracts
	Interfaces
		Advanced interfaces
	Library
		Importing a library
	Summary
	Questions
	Further reading
Chapter 7: Solidity Functions, Modifiers, and Fallbacks
	Technical requirements
	Function input and output
	Modifiers
	Visibility scope
	View, constant, and pure functions
	Address-related functions
		The address send method
		The address transfer method
		The address call method
		The address callcode method
		The address delegatecall method
		The address staticcall method
	The fallback and receive functions
	Summary
	Questions
	Further reading
Chapter 8: Exceptions, Events, and Logging
	Technical requirements
	Exception handling
		Require
		Assert
		Revert
	Try-catch in Solidity
	Events and logging
	Summary
	Questions
	Further reading
Chapter 9: Basics of Truffle and Unit Testing
	Technical requirements
	Application development life cycle management
	Introducing Truffle
	Development with Truffle
	Testing with Truffle
	Interactively working with Truffle
	Summary
	Questions
	Further reading
Chapter 10: Debugging Contracts
	Technical requirements
	Overview of debugging
	The Remix editor
	Using events
	Using a block explorer
	Summary
	Questions
	Further reading
Part 3: Advanced Smart Contracts
Chapter 11: Assembly Programming
	Technical requirements
	An introduction to Solidity and its advantages
	Getting started with Assembly programming
	Scopes and blocks
	Returning values
	Working with memory slots
	Working with storage slots
	Calling contract functions
	Determining contract addresses
	Summary
	Questions
	Further reading
Chapter 12: Upgradable Smart Contracts
	Technical requirements
	Learning what constitutes upgradability
	Understanding dependency injection
		Providing instance addresses during contract deployment
		Providing instance addresses following contract deployment
	Reviewing problematic smart contracts
	Implementing simple solutions with inheritance
	Implementing simple solutions with composition
	Implementing advanced solutions using proxy contracts
	Writing upgradable contracts with upgradable storage
	Summary
	Questions
	Further reading
Chapter 13: Writing Secure Contracts
	Technical requirements
	SafeMath and under/overflow attacks
	Reentrancy attack
	The EtherPot contract
	The Hacker contract
	Solutions to the reentrancy problem
	Security best practices
	Summary
	Questions
	Further reading
Chapter 14: Writing Token Contracts
	Technical requirements
	Introducing tokens
	ERC20 Tokens
		ERC20 standard
		ERC20 functionality
		ERC20 events
	Non-fungible tokens
		ERC721
	The ERC721 implementation
		EIP223
		ERC165
	Summary
	Questions
	Further reading
Chapter 15 Solidity Design Patterns
	Technical requirements
	Introducing entity modeling
		Ethereum storage
		Data types in Ethereum
	Understanding data modeling in Solidity
		Nested versus reference fields
	Exploring types of relationships
		One-to-one relationships
		One-to-many relationships
		Many-to-many relationships
	Reviewing the rules for embedding structures
		Data cohesion
		Out-of-bounds nested structure
		Static data within a nested structure
		The nested structure will not change in the near future
		Containment relationship
		Having few relationships
	Performing data modeling using an example
		Structures
		State variables
		Adding Employees
		Retrieving a single Employees record
		Updating Employees
		Retrieving all Employees
	Ownership in smart contracts
	Exploring ownership in Solidity
		Modifier
	Establishing ownership of a smart contract
		Multiownership
		Transfer of ownership
		MultiSig contracts
		Transfer of the ownership of assets within a smart contract
	Stoppable/haltable smart contract pattern
	Summary
	Questions
	Further reading
Assessments
Index
Other Books You May Enjoy