Testing with ethers.js in Blockchain / Solidity

Introduction

Testing with ethers.js helps you check if your blockchain smart contracts work correctly before using them for real. It saves time and avoids mistakes.

When you want to make sure your smart contract functions do what you expect.

Before deploying a contract to a live blockchain to avoid costly errors.

When you want to automate checks after making changes to your contract code.

To simulate blockchain interactions like sending transactions or reading data.

When you want to learn how your contract behaves in different situations.

Syntax

Blockchain / Solidity

import { ethers } from 'ethers';

// Example: Connect to a provider
const provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');

// Example: Create a signer (an account to send transactions)
const signer = provider.getSigner(0);

// Example: Deploy or connect to a contract
const contract = new ethers.Contract(contractAddress, contractABI, signer);

// Example: Call a contract function
const result = await contract.someFunction(args);

Use ethers.providers.JsonRpcProvider() to connect to a local blockchain for testing.

Use await with contract calls because they return promises.

Examples

This connects to a local blockchain running on your computer for testing.

Blockchain / Solidity

import { ethers } from 'ethers';

// Connect to local blockchain
const provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');

This gets the first account from the local blockchain to act as the sender.

Blockchain / Solidity

const signer = provider.getSigner(0);

// Use the first account to send transactions

This lets you call contract functions that change data.

Blockchain / Solidity

const contract = new ethers.Contract(address, abi, signer);

// Connect to your deployed contract with signer to send transactions

This calls a contract function that only reads data and prints the result.

Blockchain / Solidity

const value = await contract.readValue();
console.log(value);

Sample Program

This program connects to a local blockchain, reads a value from a contract, updates it, and reads it again to confirm the change.

Blockchain / Solidity

import { ethers } from 'ethers';

async function main() {
  // Connect to local blockchain
  const provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');

  // Get first account signer
  const signer = provider.getSigner(0);

  // Simple contract ABI and address (example)
  const abi = [
    'function getValue() view returns (uint256)',
    'function setValue(uint256 newValue)'
  ];
  const address = '0x0000000000000000000000000000000000000001';

  // Connect to contract
  const contract = new ethers.Contract(address, abi, signer);

  // Call read function
  const oldValue = await contract.getValue();
  console.log('Old value:', oldValue.toString());

  // Call write function
  const tx = await contract.setValue(42);
  await tx.wait();
  console.log('Value updated');

  // Read updated value
  const newValue = await contract.getValue();
  console.log('New value:', newValue.toString());
}

main().catch(console.error);

Important Notes

Make sure your local blockchain (like Hardhat or Ganache) is running before testing.

Use await tx.wait() to wait for the transaction to be confirmed.

Contract address and ABI must match your deployed contract for tests to work.

Summary

Testing with ethers.js lets you interact with smart contracts in code to check their behavior.

You connect to a blockchain provider, get a signer, and call contract functions.

Always wait for transactions to confirm before checking results.

Practice

1. What is the main purpose of using ethers.js in testing smart contracts?

easy

A. To create new blockchain networks

B. To design the user interface of a blockchain app

C. To mine new blocks on the blockchain

D. To interact with smart contracts and verify their behavior programmatically

Solution

1. Step 1: Understand ethers.js role

   ethers.js is a library that helps developers interact with Ethereum smart contracts in code.

2. Step 2: Identify testing purpose

   In testing, ethers.js lets you call contract functions and check if they behave as expected.

3. Final Answer:

   To interact with smart contracts and verify their behavior programmatically -> Option D

4. Quick Check:

   ethers.js tests contract behavior = A [OK]

Hint: Remember: ethers.js tests contracts by calling their functions [OK]

Common Mistakes:

• Confusing ethers.js with UI design tools
• Thinking ethers.js mines blocks
• Assuming ethers.js creates blockchains

2. Which of the following is the correct way to get a signer from a provider in ethers.js?

easy

A. const signer = provider.signer();

B. const signer = provider.getSigner();

C. const signer = provider.getsigner();

D. const signer = provider.sign();

Solution

1. Step 1: Recall ethers.js signer method

   The correct method to get a signer from a provider is getSigner() with capital S.

2. Step 2: Check method spelling and casing

   Options B, C, and D have incorrect method names or casing.

3. Final Answer:

   const signer = provider.getSigner(); -> Option B

4. Quick Check:

   Correct method is getSigner() = A [OK]

Hint: Method names are case-sensitive; use getSigner() exactly [OK]

Common Mistakes:

• Using wrong casing like signer() instead of getSigner()
• Misspelling method names
• Confusing signer with sign

3. Consider this ethers.js test code snippet:

const tx = await contract.setValue(42);
await tx.wait();
const value = await contract.getValue();
console.log(value);

What will be printed to the console?

medium

A. 42

B. undefined

C. Transaction hash

D. Error: contract.getValue is not a function

Solution

1. Step 1: Understand transaction and wait

   The code calls setValue(42) on the contract, then waits for the transaction to confirm with tx.wait().

2. Step 2: Retrieve stored value

   After confirmation, it calls getValue() which returns the stored value 42.

3. Final Answer:

   42 -> Option A

4. Quick Check:

   Confirmed setValue(42) then getValue() = 42 [OK]

Hint: Always wait for tx confirmation before reading updated state [OK]

Common Mistakes:

• Not awaiting tx.wait() before reading value
• Expecting transaction hash instead of value
• Assuming getValue() is undefined

4. You wrote this test code but it throws an error:

const tx = contract.setValue(10);
await tx.wait();

What is the likely cause of the error?

medium

A. Missing await before contract.setValue(10)

B. tx.wait() is not a function

C. contract.setValue does not exist

D. Provider is not connected

Solution

1. Step 1: Check async call to contract method

   contract.setValue(10) returns a Promise, so it must be awaited to get the transaction object.

2. Step 2: Identify missing await issue

   Without await, tx is a Promise, which does not have a wait() method, causing the error.

3. Final Answer:

   Missing await before contract.setValue(10) -> Option A

4. Quick Check:

   Await async call before tx.wait() = C [OK]

Hint: Always await contract calls returning transactions before wait() [OK]

Common Mistakes:

• Forgetting await before async contract calls
• Assuming tx is transaction without awaiting
• Not checking provider connection first

5. You want to test a smart contract function transfer(address to, uint amount) that emits an event Transfer. Which ethers.js testing approach correctly waits for the transaction and verifies the event was emitted?

hard

A. await contract.transfer(addr, 100);
expect(tx.events[0].event).to.equal('Transfer');

B. const receipt = await contract.transfer(addr, 100);
expect(receipt.events[0].event).to.equal('Transfer');

C. const tx = await contract.transfer(addr, 100);
const receipt = await tx.wait();
expect(receipt.events[0].event).to.equal('Transfer');

D. const tx = contract.transfer(addr, 100);
expect(tx.events[0].event).to.equal('Transfer');

Solution

1. Step 1: Await the transaction call

   Use await to get the transaction object from contract.transfer.

2. Step 2: Wait for transaction confirmation and get receipt

   Call tx.wait() to get the receipt which contains event logs.

3. Step 3: Verify event in receipt

   Check receipt.events[0].event equals 'Transfer' to confirm event emitted.

4. Final Answer:

   const tx = await contract.transfer(addr, 100); const receipt = await tx.wait(); expect(receipt.events[0].event).to.equal('Transfer'); -> Option C

5. Quick Check:

   Await tx, wait receipt, check event = D [OK]

Hint: Always await tx, then wait for receipt to check events [OK]

Common Mistakes:

• Not awaiting transaction before wait()
• Trying to access events on tx instead of receipt
• Ignoring event verification after transaction