Chapter 1. A first look at decentralized applications
1.1.1. Dapps vs. conventional centralized applications
1.1.2. Structural view: Anatomy of a Dapp
1.1.3. Transactional view: Through the lifecycle of a transaction
1.3. A five-minute Dapp implementation
Chapter 2. Understanding the blockchain
2.1. A deeper look at decentralized applications
2.1.1. Inside an Ethereum node
2.1.2. Revisiting the lifecycle of a transaction
2.1.3. Development view: Deploying the voting smart contract
2.2. What technologies make Dapps viable?
2.3. Ethereum’s history and governance
Chapter 3. The Ethereum platform
3.1. Connecting to Ethereum through the wallet
3.2. Smart contracts: The brain of Dapps
3.3. Connecting to Ethereum with geth
3.3.1. Getting started with geth
3.3.2. A first look at the geth interactive console
3.3.3. A first look at JSON-RPC
3.4. Managing accounts with geth
3.4.2. Managing accounts with the geth command
3.5. Revisiting SimpleCoin’s contract
3.5.1. Improving SimpleCoin’s contract
3.5.2. Trying out the amended code
3.5.3. How does the coin transfer execute in the Ethereum network?
Chapter 4. Deploying your first smart contract
4.1. Deploying a contract onto the network
4.2. Interacting with the contract
4.3. Nodeless deployment through MetaMask
Chapter 5. Programming smart contracts in Solidity
5.2. High-level contract structure
5.3. Solidity language essentials
5.4. Time to improve and refactor SimpleCoin
Chapter 6. Writing more complex smart contracts
6.1. Introducing SimpleCrowdsale, a crowdsale contract
6.1.4. Implementing finalize()
6.1.5. Small detour: Introducing inheritance
6.1.6. Implementing finalize(), take 2
6.2. Extending functionality with inheritance
6.2.1. Implementing a new token pricing contract with inheritance
Chapter 7. Generalizing functionality with abstract contracts and interfaces
7.1. Making a contract abstract
7.1.1. Implementing funding limit with inheritance
7.1.2. Generalizing funding limit strategy with an abstract contract
7.1.3. Improving the token pricing strategy with an abstract contract
7.2. Allowing multiple contract implementations with interfaces
7.3. Real-world crowdsale contracts
7.4. Recap of Solidity’s object-oriented features
Chapter 8. Managing smart contracts with Web3.js
8.1. Revisiting deployment through geth’s interactive console
8.2. Interacting with SimpleCoin through geth’s console
8.3. Simplifying command-based deployment with Node.js
8.3.1. Installing Web3 and solc on Node.js
8.3.2. Building and deploying interactively through the Node.js console
8.4. Deploying on a private network
8.4.1. How geth accesses the blockchain
8.5. Making development more efficient by deploying on mock networks
8.6. Smoother interaction with SimpleCoin through a web UI
Chapter 9. The Ethereum ecosystem
9.2. A bird’s-eye view of the full ecosystem
9.3. Decentralized address resolution with ENS
9.4. Decentralized content storage
9.5. Accessing external data through oracles
Chapter 10. Unit testing contracts with Mocha
10.2. Setting up SimpleCoin in Mocha
10.3. Writing unit tests for SimpleCoin
10.3.2. Unit testing the constructor
10.3.3. Testing whether only authorized callers can invoke a function
10.3.4. Testing if input constraints are met
10.3.5. Testing invocation from an authorized account with valid input
Chapter 11. Improving the development cycle with Truffle
11.2. Moving SimpleCoin under Truffle
11.2.1. Setting up SimpleCoin in Truffle
11.2.4. Deploying SimpleCoin onto a mock network client through migrations
11.2.5. Deploying SimpleCoin onto a public test or production network
Chapter 12. Putting it all together: Building a complete voting Dapp
12.1. Defining the requirements of a voting Dapp
12.3. Starting the Truffle project
12.4. Implementing the voting contract
12.5. Compiling and deploying SimpleVoting
12.7.1. Preparing the UI dependencies
12.7.2. Setting up a minimalistic web server with Node.js
12.7.3. Writing the admin page HTML
12.7.4. Writing the admin page JavaScript
12.7.5. Writing the voter page HTML
12.7.6. Writing the voter page JavaScript
Chapter 13. Making a Dapp production ready
13.2. Designing an upgradeable library
13.3. Designing an upgradeable contract
Chapter 14. Security considerations
14.1. Understanding general security weak spots
14.2. Understanding risks associated with external calls
14.2.1. Understanding external call execution types
14.2.2. What external function can you call?
14.2.3. Is an exception thrown if the external call fails?
14.2.4. Which context is the external call executed in?
14.3. How to perform external calls more safely
14.3.1. Implementing pull payments
14.3.2. Implementing a minimal fallback function
14.3.3. Beware of Ether coming to you through selfdestruct()
14.4. Avoiding known security attacks
14.4.2. Cross-function race conditions
15.2. Alternative Ethereum implementations
15.3. Beyond the Ethereum blockchain
A. SimpleCoin inherited from Ownable
B. Full SimpleCrowdsale application
C. SimpleCoin Mocha unit testing suite