Book Image

Solidity Programming Essentials. - Second Edition

By : Ritesh Modi
Book Image

Solidity Programming Essentials. - Second Edition

By: Ritesh Modi

Overview of this book

Solidity is a high-level language for writing smart contracts, and the syntax has large similarities with JavaScript, thereby making it easier for developers to learn, design, compile, and deploy smart contracts on large blockchain ecosystems including Ethereum and Polygon among others. This book guides you in understanding Solidity programming from scratch. The book starts with step-by-step instructions for the installation of multiple tools and private blockchain, along with foundational concepts such as variables, data types, and programming constructs. You’ll then explore contracts based on an object-oriented paradigm, including the usage of constructors, interfaces, libraries, and abstract contracts. The following chapters help you get to grips with testing and debugging smart contracts. As you advance, you’ll learn about advanced concepts like assembly programming, advanced interfaces, usage of recovery, and error handling using try-catch blocks. You’ll also explore multiple design patterns for smart contracts alongside developing secure smart contracts, as well as gain a solid understanding of writing upgradable smart concepts and data modeling. Finally, you’ll discover how to create your own ERC20 and NFT tokens from scratch. By the end of this book, you will be able to write, deploy, and test smart contracts in Ethereum.

Related Content you might be interested in

Current Title:

Small book image
Solidity Programming Essentials. - Second Edition
Ritesh Modi
Jun, 2022 | 412 pages
Small book image
Spring 5.0 Projects
Nilang Patel
Feb, 2019 | 442 pages
Table of Contents (21 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Part 1: The Fundamentals of Solidity and Ethereum
Part 1: The Fundamentals of Solidity and Ethereum
Free Chapter
2
Chapter 1: An Introduction to Blockchain, Ethereum, and Smart Contracts
Chapter 1: An Introduction to Blockchain, Ethereum, and Smart Contracts
Technical requirements
What is a blockchain?
The need for blockchain
Understanding cryptography
Consensus
Ethereum nodes
Ethereum accounts
Blocks
An end-to-end transaction
Smart contract
The internals of smart contract deployment
Summary
Questions
Further reading
3
Chapter 2: Installing Ethereum and Solidity
Chapter 2: Installing Ethereum and Solidity
Technical requirements
Ethereum networks
Installing and configuring Geth
Creating a private network
Installing Ganache
Installing the Solidity compiler
Installing the web3 framework
Installing and using MetaMask
Summary
Questions
Further reading
4
Chapter 3: Introducing Solidity
Chapter 3: Introducing Solidity
Technical requirements
The Ethereum Virtual Machine
Understanding Solidity and Solidity files
The structure of a contract
Exploring data types in Solidity
Storage and memory data locations
Using literals
Understanding integers
Understanding Boolean
The byte data type
Understanding arrays
Knowing more about the structure of an array
Enumerations
Understanding the address data type
Working with mappings
Summary
Questions
Further reading
5
Chapter 4: Global Variables and Functions
Chapter 4: Global Variables and Functions
Technical requirements
Variable scoping
Type conversion
Block and transaction global variables
Cryptographic global variables
Address global variables
Contract global variables
Recovering addresses using ecrecover
Summary
Questions
Further reading
6
Chapter 5: Expressions and Control Structures
Chapter 5: Expressions and Control Structures
Technical requirements
Understanding Solidity expressions
Understanding the if and if...else decision controls
Exploring while loops
Understanding the do...while loop
Understanding breaks
Understanding continue
Understanding return
Summary
Questions
Further reading
7
Part 2: Writing Robust Smart Contracts
Part 2: Writing Robust Smart Contracts
8
Chapter 6: Writing Smart Contracts
Chapter 6: Writing Smart Contracts
Technical requirements
Smart contracts
Writing a smart contract
Creating contracts
Contract constructor
Contract composition
Inheritance
Encapsulation
Polymorphism
Method overriding
Abstract contracts
Interfaces
Library
Summary
Questions
Further reading
9
Chapter 7: Solidity Functions, Modifiers, and Fallbacks
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 fallback and receive functions
Summary
Questions
Further reading
10
Chapter 8: Exceptions, Events, and Logging
Chapter 8: Exceptions, Events, and Logging
Technical requirements
Exception handling
Try-catch in Solidity
Events and logging
Summary
Questions
Further reading
11
Chapter 9: Basics of Truffle and Unit Testing
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
12
Chapter 10: Debugging Contracts
Chapter 10: Debugging Contracts
Technical requirements
Overview of debugging
The Remix editor
Using events
Using a block explorer
Summary
Questions
Further reading
13
Part 3: Advanced Smart Contracts
Part 3: Advanced Smart Contracts
14
Chapter 11: Assembly Programming
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
15
Chapter 12: Upgradable Smart Contracts
Chapter 12: Upgradable Smart Contracts
Technical requirements
Learning what constitutes upgradability
Understanding dependency injection
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
16
Chapter 13: Writing Secure Contracts
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
17
Chapter 14: Writing Token Contracts
Chapter 14: Writing Token Contracts
Technical requirements
Introducing tokens
ERC20 Tokens
Non-fungible tokens
The ERC721 implementation
Summary
Questions
Further reading
18
Chapter 15: Solidity Design Patterns
Chapter 15: Solidity Design Patterns
Technical requirements
Introducing entity modeling
Understanding data modeling in Solidity
Exploring types of relationships
Reviewing the rules for embedding structures
Performing data modeling using an example
Ownership in smart contracts
Exploring ownership in Solidity
Establishing ownership of a smart contract
Stoppable/haltable smart contract pattern
Summary
Questions
Further reading
19
Assessments
Assessments
Chapter 1, Introduction to Blockchain, Ethereum, and Smart Contracts
Chapter 2, Installing Ethereum and Solidity
Chapter 3, Introducing Solidity
Chapter 4, Global Variables and Functions
Chapter 5, Expressions and Control Structures
Chapter 6, Writing Smart Contracts
Chapter 7, Functions, Modifiers, and Fallbacks
Chapter 8, Exceptions, Events, and Logging
Chapter 9, Truffle Basics and Unit Testing
Chapter 10, Debugging Contracts
Chapter 11, Assembly Programming
Chapter 12, Upgradable Smart Contracts
Chapter 13, Writing Secure Contracts
Chapter 14, Writing Token Contracts
Chapter 15, Solidity Design Patterns
Why subscribe?
20
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Abstract contracts

Abstract contracts are contracts that have partial function definitions. You cannot create an instance of an abstract contract. An abstract contract must be inherited by a child contract to utilize its functions.

Abstract contracts help in defining the structure of a contract, and any class inheriting from it must ensure to provide an implementation for them. If the child contract does not provide the implementation for incomplete functions, its instance cannot be created. The function signature is terminated using a semicolon (;). Solidity provides an abstract keyword to mark a contract as abstract. This is a relatively new keyword addition and it was not part of prior versions. A contract becomes an abstract contract when it consists of functions without any implementation.

The following code snippet is an implementation of an abstract contract.

The abstractHelloWorld contract is an abstract contract as it contains a couple of functions without any...

Previous Section
End of Section 12
Next Section