book

Mastering Ethereum

by Andreas M. Antonopoulos, Gavin Wood

December 2018

Intermediate to advanced

422 pages

11h 8m

English

O'Reilly Media, Inc.

Read now

Unlock full access

How to Use This BookIntended AudienceConventions Used in This BookCode ExamplesUsing Code ExamplesReferences to Companies and ProductsEthereum Addresses and Transactions in this BookO’Reilly SafariHow to Contact UsContacting AndreasContacting GavinAcknowledgments by AndreasAcknowledgments by GavinContributionsSources
Compared to BitcoinComponents of a BlockchainThe Birth of EthereumEthereum’s Four Stages of DevelopmentEthereum: A General-Purpose BlockchainEthereum’s ComponentsFurther ReadingEthereum and Turing CompletenessTuring Completeness as a “Feature”Implications of Turing CompletenessFrom General-Purpose Blockchains to Decentralized Applications (DApps)The Third Age of the InternetEthereum’s Development CultureWhy Learn Ethereum?What This Book Will Teach You
Ether Currency UnitsChoosing an Ethereum WalletControl and ResponsibilityGetting Started with MetaMaskCreating a WalletSwitching NetworksGetting Some Test EtherSending Ether from MetaMaskExploring the Transaction History of an AddressIntroducing the World ComputerExternally Owned Accounts (EOAs) and ContractsA Simple Contract: A Test Ether FaucetCompiling the Faucet ContractCreating the Contract on the BlockchainInteracting with the ContractViewing the Contract Address in a Block ExplorerFunding the ContractWithdrawing from Our ContractConclusions
Ethereum NetworksShould I Run a Full Node?Full Node Advantages and DisadvantagesPublic Testnet Advantages and DisadvantagesLocal Blockchain Simulation Advantages and DisadvantagesRunning an Ethereum ClientHardware Requirements for a Full NodeSoftware Requirements for Building and Running a Client (Node)ParityGo-Ethereum (Geth)The First Synchronization of Ethereum-Based BlockchainsRunning Geth or ParityThe JSON-RPC InterfaceRemote Ethereum ClientsMobile (Smartphone) WalletsBrowser WalletsConclusions
Keys and AddressesPublic Key Cryptography and CryptocurrencyPrivate KeysGenerating a Private Key from a Random NumberPublic KeysElliptic Curve Cryptography ExplainedElliptic Curve Arithmetic OperationsGenerating a Public KeyElliptic Curve LibrariesCryptographic Hash FunctionsEthereum’s Cryptographic Hash Function: Keccak-256Which Hash Function Am I Using?Ethereum AddressesEthereum Address FormatsInter Exchange Client Address ProtocolHex Encoding with Checksum in Capitalization (EIP-55)Conclusions
Wallet Technology OverviewNondeterministic (Random) WalletsDeterministic (Seeded) WalletsHierarchical Deterministic Wallets (BIP-32/BIP-44)Seeds and Mnemonic Codes (BIP-39)Wallet Best PracticesMnemonic Code Words (BIP-39)Creating an HD Wallet from the SeedHD Wallets (BIP-32) and Paths (BIP-43/44)Conclusions
The Structure of a TransactionThe Transaction NonceKeeping Track of NoncesGaps in Nonces, Duplicate Nonces, and ConfirmationConcurrency, Transaction Origination, and NoncesTransaction GasTransaction RecipientTransaction Value and DataTransmitting Value to EOAs and ContractsTransmitting a Data Payload to an EOA or ContractSpecial Transaction: Contract CreationDigital SignaturesThe Elliptic Curve Digital Signature AlgorithmHow Digital Signatures WorkVerifying the SignatureECDSA MathTransaction Signing in PracticeRaw Transaction Creation and SigningRaw Transaction Creation with EIP-155The Signature Prefix Value (v) and Public Key RecoverySeparating Signing and Transmission (Offline Signing)Transaction PropagationRecording on the BlockchainMultiple-Signature (Multisig) TransactionsConclusions
What Is a Smart Contract?Life Cycle of a Smart ContractIntroduction to Ethereum High-Level LanguagesBuilding a Smart Contract with SoliditySelecting a Version of SolidityDownload and InstallDevelopment EnvironmentWriting a Simple Solidity ProgramCompiling with the Solidity Compiler (solc)The Ethereum Contract ABISelecting a Solidity Compiler and Language VersionProgramming with SolidityData TypesPredefined Global Variables and FunctionsContract DefinitionFunctionsContract Constructor and selfdestructAdding a Constructor and selfdestruct to Our Faucet ExampleFunction ModifiersContract InheritanceError Handling (assert, require, revert)EventsCalling Other Contracts (send, call, callcode, delegatecall)Gas ConsiderationsAvoid Dynamically Sized ArraysAvoid Calls to Other ContractsEstimating Gas CostConclusions
Vulnerabilities and VyperComparison to SolidityModifiersClass InheritanceInline AssemblyFunction OverloadingVariable TypecastingPreconditions and PostconditionsDecoratorsFunction and Variable OrderingCompilationProtecting Against Overflow Errors at the Compiler LevelReading and Writing DataConclusions

Security Best PracticesSecurity Risks and AntipatternsReentrancyReal-World Example: The DAOArithmetic Over/UnderflowsReal-World Examples: PoWHC and Batch Transfer Overflow (CVE-2018–10299)Unexpected EtherFurther ExamplesDELEGATECALLReal-World Example: Parity Multisig Wallet (Second Hack)Default VisibilitiesReal-World Example: Parity Multisig Wallet (First Hack)Entropy IllusionReal-World Example: PRNG ContractsExternal Contract ReferencingReal-World Example: Reentrancy Honey PotShort Address/Parameter AttackUnchecked CALL Return ValuesReal-World Example: Etherpot and King of the EtherRace Conditions/Front RunningReal-World Examples: ERC20 and BancorDenial of Service (DoS)Real-World Examples: GovernMentalBlock Timestamp ManipulationReal-World Example: GovernMentalConstructors with CareReal-World Example: RubixiUninitialized Storage PointersReal-World Examples: OpenAddressLottery and CryptoRoulette Honey PotsFloating Point and PrecisionReal-World Example: EthstickTx.Origin AuthenticationContract LibrariesConclusions
How Tokens Are UsedTokens and FungibilityCounterparty RiskTokens and IntrinsicalityUsing Tokens: Utility or EquityIt’s a Duck!Utility Tokens: Who Needs Them?Tokens on EthereumThe ERC20 Token StandardLaunching Our Own ERC20 TokenIssues with ERC20 TokensERC223: A Proposed Token Contract Interface StandardERC777: A Proposed Token Contract Interface StandardERC721: Non-fungible Token (Deed) StandardUsing Token StandardsWhat Are Token Standards? What Is Their Purpose?Should You Use These Standards?Security by MaturityExtensions to Token Interface StandardsTokens and ICOsConclusions
Why Oracles Are NeededOracle Use Cases and ExamplesOracle Design PatternsData AuthenticationComputation OraclesDecentralized OraclesOracle Client Interfaces in SolidityConclusions
What Is a DApp?Backend (Smart Contract)Frontend (Web User Interface)Data StorageDecentralized Message Communications ProtocolsA Basic DApp Example: Auction DAppAuction DApp: Backend Smart ContractsAuction DApp: Frontend User InterfaceFurther Decentralizing the Auction DAppStoring the Auction DApp on SwarmPreparing SwarmUploading Files to SwarmThe Ethereum Name Service (ENS)History of Ethereum Name ServicesThe ENS SpecificationBottom Layer: Name Owners and ResolversMiddle Layer: The .eth NodesTop Layer: The DeedsRegistering a NameManaging Your ENS NameENS ResolversResolving a Name to a Swarm Hash (Content)From App to DAppConclusions
What Is the EVM?Comparison with Existing TechnologyThe EVM Instruction Set (Bytecode Operations)Ethereum StateCompiling Solidity to EVM BytecodeContract Deployment CodeDisassembling the BytecodeTuring Completeness and GasGasGas Accounting During ExecutionGas Accounting ConsiderationsGas Cost Versus Gas PriceBlock Gas LimitConclusions
Consensus via Proof of WorkConsensus via Proof of Stake (PoS)Ethash: Ethereum’s Proof-of-Work AlgorithmCasper: Ethereum’s Proof-of-Stake AlgorithmPrinciples of ConsensusControversy and CompetitionConclusions
Ethereum Classic (ETC)The Decentralized Autonomous Organization (The DAO)The Reentrancy BugTechnical DetailsAttack FlowThe DAO Hard ForkTimeline of the DAO Hard ForkEthereum and Ethereum ClassicThe EVMCore Network DevelopmentOther Notable Ethereum Forks
Ethereum Improvement Proposals (EIPs)Table of Most Important EIPs and ERCs
FrameworksTruffleEmbarkOpenZeppelinZeppelinOSUtilitiesEthereumJS helpeth: A Command-Line Utilitydapp.toolsSputnikVMLibrariesweb3.jsweb3.pyEthereumJSweb3jEtherJarNethereumethers.jsEmerald PlatformTesting Smart ContractsOn-Blockchain TestingGanache: A Local Test Blockchain
Descriptionweb3.js Contract Basic Interaction in a Nonblocked (Async) FashionNode.js Script ExecutionReviewing the Demo ScriptContract InteractionAsynchronous Operation with Await
Smart Contract SecurityTokens

Overview

Ethereum represents the gateway to a worldwide, decentralized computing paradigm. This platform enables you to run decentralized applications (DApps) and smart contracts that have no central points of failure or control, integrate with a payment network, and operate on an open blockchain. With this practical guide, Andreas M. Antonopoulos and Gavin Wood provide everything you need to know about building smart contracts and DApps on Ethereum and other virtual-machine blockchains.

Discover why IBM, Microsoft, NASDAQ, and hundreds of other organizations are experimenting with Ethereum. This essential guide shows you how to develop the skills necessary to be an innovator in this growing and exciting new industry.

Run an Ethereum client, create and transmit basic transactions, and program smart contracts
Learn the essentials of public key cryptography, hashes, and digital signatures
Understand how "wallets" hold digital keys that control funds and smart contracts
Interact with Ethereum clients programmatically using JavaScript libraries and Remote Procedure Call interfaces
Learn security best practices, design patterns, and anti-patterns with real-world examples
Create tokens that represent assets, shares, votes, or access control rights
Build decentralized applications using multiple peer-to-peer (P2P) components