Lesson 14 of 14
In Progress

Recap of Key Concepts and Next Steps for Continuing to Learn and Develop with Web3.js

Congratulations on completing this course on Web3.js! You should now have a solid foundation for working with the Web3.js library and building decentralized applications (DApps) on the Ethereum blockchain.

In this course, we covered the following key concepts:

  • What Web3.js is and how it works
  • Setting up your development environment for working with Web3.js
  • Connecting to a local or remote Ethereum blockchain
  • Writing and deploying smart contracts with Solidity
  • Executing transactions and calling functions on smart contracts
  • Reading data from the Ethereum blockchain
  • Querying the Ethereum blockchain
  • Working with events and logs in DApps
  • Implementing secure authentication and authorization
  • Best practices for developing with Web3.js

We also provided exercises and solutions for each topic to help you practice and apply what you learned.

Now that you have completed this course, you may be wondering what your next steps should be for continuing to learn and develop with Web3.js. Here are some suggestions:

Explore More Advanced Topics in Web3.js

There are many advanced topics in Web3.js that we did not cover in this course. Some examples include:

  • Working with asynchronous code in Web3.js
  • Debugging smart contracts and DApps
  • Interacting with other Ethereum clients (e.g. Parity, Geth)
  • Building more complex DApps with frameworks like Truffle or Embark
  • Integrating Web3.js with front-end libraries like React or Angular

You can find more information on these topics by consulting the Web3.js documentation or other online resources.

Practice Building DApps

The best way to improve your skills in Web3.js and DApp development is to build DApps yourself. Start by building simple DApps that showcase the basic functionality you learned in this course (e.g. reading and writing data to the blockchain, executing transactions). Then, try building more complex DApps that incorporate additional features (e.g. authentication and authorization, events and logs).

You can also try building DApps that solve real-world problems or address specific use cases. For example, you could build a DApp that allows users to buy and sell goods or services using cryptocurrency, or a DApp that allows users to track the supply chain of a product.

Join the Ethereum Developer Community

There is a vibrant community of Ethereum developers around the world who are building and experimenting with new DApps and technologies. You can join this community by participating in online forums, attending meetups or conferences, and contributing to open source projects.

One good place to start is the Ethereum Stack Exchange, which is a forum for asking and answering questions about Ethereum development. You can also join the Ethereum subreddit, which is a discussion forum for all things Ethereum.

Finally, consider joining a local Ethereum developer group or starting your own. This is a great way to meet other Ethereum developers and learn from them in person.

We hope you enjoyed this course and that you are excited to continue learning and developing with Web3.js. We look forward to seeing the innovative DApps you build!


To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.

Write a function that asynchronously retrieves the balance of an Ethereum account using Web3.js.

async function getAccountBalance(address) {
  const balance = await web3.eth.getBalance(address);
  console.log(`Balance of account ${address}: ${balance} wei`);

Write a function that debugs a smart contract by printing out the values of all its variables.

function debugContract(contract) {
  const instance = new web3.eth.Contract(contract.abi, contract.address);
  for (let i = 0; i < contract.abi.length; i++) {
    const abiDefinition = contract.abi[i];
    if (abiDefinition.type === 'function' && abiDefinition.inputs.length === 0 && abiDefinition.outputs.length > 0) {
      const result = instance.methods[abiDefinition.name]().call();
      console.log(`${abiDefinition.name}: ${result}`);

Write a function that integrates Web3.js with a React front-end by fetching data from a smart contract and displaying it in a table.

class ContractDataTable extends React.Component {
  constructor(props) {
    this.state = {
      data: []

  async componentDidMount() {
    const contract = new web3.eth.Contract(this.props.abi, this.props.address);
    const data = await contract.methods.getData().call();
    this.setState({ data });

  render() {
    return (
          {this.state.data.map((row, index) => (
            <tr key={index}>

Write a function that listens for events emitted by a smart contract and logs the event data to the console.

function listenForEvents(contract, eventName) {
  contract.events[eventName]({}, (error, event) => {
    if (error) {
    } else {

Write a function that signs a message using an Ethereum account’s private key and returns the signed message.

async function signMessage(privateKey, message) {
  const account = web3.eth.accounts.privateKeyToAccount(privateKey);
  const signedMessage = await account.sign(message);
  return signedMessage;