Building Ethereum ĐApps
Decentralized Applications on the Ethereum Blockchain
Roberto Infante
  • MEAP began December 2017
  • Publication in January 2019 (estimated)
  • ISBN 9781617295157
  • 375 pages (estimated)
  • printed in black & white

It's a great introduction to Solidity and the Ethereum development ecosystem, great visuals, and detailed definitions. It's strong technically and not too wordy.

Godfred Asamoah
There's a lot of Google-buzz about the explosion of cryptocurrencies like Bitcoin and Ether and the "blockchain" programming model that makes them work. Decentralized applications, aka DApps, extend blockchain beyond cryptocurrency, providing an innovative way to support private, secure, peer-to-peer transactions. DApps offer app developers the same advantages as a cryptocurrency like Bitcoin. DApp transactions are signed and stored cryptographically. Logic and state are decentralized over the nodes of a wide network, and records are immutable. Building Ethereum ĐApps teaches you how to exploit these benefits and the blockchain to build powerful distributed apps with Ethereum!
Table of Contents detailed table of contents

Part 1: Getting Started With Ethereum

1. A first look at decentralized applications

1.1. What is a Dapp?

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.1.4. Let’s get familiar with some Dapp terminology

1.2. Good and bad Dapps

1.2.1. Good use cases

1.2.2. Pointless Dapps

1.3. A five-minute Dapp implementation

1.3.1. Let’s start building SimpleCoin, a basic cryptocurrency

1.3.2. Let’s run the contract

1.3.3. Let’s interact with the contract

1.4. Summary

2. Understanding the blockchain

2.1. A deeper look at decentralized applications

2.1.1. Stepping into 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.2.1. Blockchain technologies

2.2.2. Ethereum technologies

2.3. Summary

3. The Ethereum platform

3.1. Connecting to Ethereum through the wallet

3.1.1. Getting started with the Ethereum wallet

3.1.2. Performing common operations with the wallet

3.2. Smart contracts: the brain of Dapps

3.2.1. Accounts

3.2.2. Ether

3.2.3. Gas

3.2.4. Calls and transactions

3.2.5. The Ethereum Virtual Machine

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.3.4. Mining with geth console

3.3.5. Other clients

3.4. Managing accounts with geth

3.4.1. Ethereum accounts

3.4.2. Managing accounts with the geth command

3.4.3. Managing accounts with Web3 on the geth console

3.4.4. Managing accounts with JSON-RPC

3.5. Revisiting SimpleCoin’s contract

3.5.1. Improving SimpleCoin’s contract

3.5.2. Trying out the amended code

3.6. Summary

4. Deploying your first smart contract

4.1. Deploying a contract onto the network

4.1.1. Ethereum public networks

4.1.2. Deploying SimpleCoin with the Ethereum Wallet

4.2. Interacting with the contract

4.2.1. Checking coin balances

4.2.2. Transferring coins

4.3. Nodeless deployment through Metamask

4.3.1. Installing metamask

4.3.2. Deploying SimpleCoin through Metamask

4.3.3. Interacting with SimpleCoin through Metamask

4.4. Summary

Part 2: Implementing Smart Contracts

5. Programming smart contracts in Solidity

5.1. EVM contract languages

5.1.1. LLL

5.1.2. Serpent and Viper

5.2. High-level contract structure

5.2.1. Contract declarations

5.3. Solidity language essentials

5.3.1. Value types

5.3.2. Reference types

5.3.3. Global namespace

5.3.4. State variables

5.3.5. Functions

5.3.6. Function modifiers

5.3.7. Variable declaration, initialization and assignment

5.3.8. Events

5.3.9. Conditional statements

5.4. Time to improve and refactor SimpleCoin

5.4.1. Implementing an allowance facility

5.4.2. Restricting operations only to the contract owner

5.5. Summary

6. Writing more complex smart contracts

6.1. Introducing SimpleCrowdsale, a crowdsale contract

6.1.1. State variables

6.1.2. Constructor

6.1.3. Implementing invest()

6.1.4. Implementing finalize()

6.1.5. Small detour: introducing inheritance

6.1.6. Implementing finalize() - take 2

6.1.7. Implementing refund()

6.1.8. Eliminating code duplication with inheritance

6.1.9. Running SimpleCrowdsale

6.2. Extending functionality with inheritance

6.2.1. Implementing a new token pricing contract with inheritance

6.2.2. Composing functionality with multiple inheritance

6.3. Summary

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 also the token pricing strategy with an abstract contract

7.1.4. Reimplementing capped crowdsales with no duplication

7.2. Allowing multiple contract implementations with interfaces

7.2.1. Setting functional requirements with interfaces

7.2.2. Referencing a contract through an interface

7.3. Real-world crowdsale contracts

7.4. Recap on Solidity’s object-oriented features

7.4.1. Inheritance

7.4.2. Abstract contracts

7.4.3. Interfaces

7.5. Libraries

7.5.1. Library function invocation

7.5.2. Deployed libraries

7.5.3. Library function execution

7.6. Making SimpleCoin ERC20 compliant

7.7. Summary

8. Managing smart contracts with Web3.js

8.1. Revisiting deployment through geth’s interactive console

8.1.1. Contract build and deployment process

8.1.2. Deploying SimpleCoin through geth’s console

8.2. Interacting with SimpleCoin through geth’s console

8.2.1. Checking coin balances

8.2.2. Transferring coins

8.2.3. Referencing a running contract

8.3. Simplifying command-based deployment with nodejs

8.3.1. Installing Web3 and solc on node.js

8.3.2. Building and deploying interactively through the node.js console

8.3.3. Creating a build and deployment script

8.3.4. Interacting with a contract from node.js.

8.4. Deploying on a private network

8.4.1. How geth accesses the blockchain

8.4.2. Setting up a private test network

8.4.3. Deploying SimpleCoin on the private network

8.5. Making development more efficient by deploying on mock networks

8.5.1. Installing and starting up TestRPC

8.5.2. Deploying SimpleCoin on TestRPC

8.6. Smoother interaction with SimpleCoin through a web UI

8.6.1. Building a minimalistic web UI for SimpleCoin

8.6.2. Running the SimpleCoin web UI

8.7. Summary

Part 3: Developing Real World DApps With The Truffle

9. The Ethereum ecosystem

9.1. The core components

9.2. A bird eye view of the full ecosystem

9.3. Decentralized address resolution with ENS

9.3.1. ENS design

9.3.2. Registering a domain name

9.3.3. Resolving a domain name

9.4. Decentralized content storage

9.4.1. Swarm overview

9.4.2. Uploading and downloading content to and from Swarm

9.4.3. IPFS overview

9.4.4. Swarm vs IPFS

9.5. Accessing external data through oracles

9.5.1. Feeding oracles

9.5.2. Building a data-aware contract with Oraclize

9.5.3. Running the data-aware contract

9.6. Dapps frameworks and IDEs

9.6.1. Development IDEs

9.6.2. Development frameworks

9.6.3. Testing frameworks

9.6.4. Web UI frameworks

9.7. Summary

10. Unit testing contracts with mocha

10.1. Installing mocha

10.2. Setting up SimpleCoin in mocha

10.3. Writing unit tests for SimpleCoin

10.3.1. The testing plan

10.3.2. Unit testing the constructor

10.3.3. Testing only authorized callers can invoke a function

10.3.4. Testing input constraints are met

10.3.5. Testing invocation from authorized account with valid input

10.3.6. A little challenge

10.3.7. The full testing suite

10.4. Summary

11. Improving the development cycle with truffle

11.1. Setting up Truffle

11.2. Moving SimpleCoin under Truffle

11.2.1. Setting up SimpleCoin in Truffle

11.2.2. Compiling SimpleCoin

11.2.3. Deploying SimpleCoin onto a mock network client through migrations

11.2.4. Deploying SimpleCoin onto a public test or production network

11.2.5. Testing SimpleCoin

11.2.6. Writing Solidity tests

11.2.7. Writing JavaScript tests

11.3. Summary

12. Putting all together: building a complete voting Dapp

Part 4: Going to production

13. Making the Dapp production ready

14. Security considerations

15. Conclusion


Appendix A: SimpleCoin inherited from Ownable

Appendix B: Full SimpleCrowdsale application

Appendix C: SimpleCoin mocha unite testing suite

Appendix D: SimpleVoting contract

About the Technology

The first decentralized blockchain applications were built on the Bitcoin platform. Ethereum was the first fully-programmable blockchain platform that enabled smart contracts--network-based programming logic that uses the blockchain to enforce transaction rules. With this development, Ethereum drew the attention of developers all over the world!

With DApps built on the Ethereum blockchain, you can establish persistent, reliable ownership records for actions such as buying a car or a house with smart contracts to enforce blockchain-based verification before a transaction can be completed. DApps can preserve intellectual property rights by establishing clear ownerships claims for digital assets like photographs or documents. DApps are also idea for securing personal records, like voting or medical histories, or establishing supply-chain provenance for goods like wine, art, or industrial parts.

About the book

Building Ethereum ĐApps introduces you to decentralized applications based on the Ethereum blockchain platform. You'll learn the principles of DApps development by rolling up your sleeves and actually building a few! You'll get a high-level overview of decentralized applications and the underlying technologies, including the Ethereum wallet and the Go Ethereum client. You'll discover how to design smart contracts to enforce transaction rules, and then implement them in Ethereum's JavaScript-like Solidity language. Because DApps are decentralized, and therefore need to be distributed across many nodes, you'll learn to deploy them onto private or public Ethereum networks.

The Ethereum ecosystem is large and growing! Along the way, you'll explore Ethereum tools such as the Truffle DApp framework, which greatly improves the efficiency of the DApp development lifecycle. As you go, you'll progressively build your knowledge and skills as you build a fully functional DApp from design to deployment.

What's inside

  • Understanding decentralized applications and the underlying technologies
  • Learning the key components of the Ethereum platform
  • Implementing smart contracts in Solidity
  • Communicating with a smart contract in Web3
  • Developing DApps with Truffle
  • Improving your design and security with best practices

About the reader

Written for developers with intermediate experience in an OO language or in JavaScript. Some understanding and experience with blockchain concepts is helpful.

About the author

Roberto Infante is an independent software development consultant who specializes in finance. Throughout his career, he has worked on a variety of innovative projects, such as the first internet mortgage approval system in the UK and one of the first online insurance underwriting systems in London.

Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.

FREE domestic shipping on three or more pBooks

A good hands-on intro to the Ethereum platform.

Jurgen Hotzel

An excellent introduction to this fascinating topic, which is changing the way we think about distributed computation.

Michael Bright