Monitoring deployed contracts in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to fetch the contract address after deployment.

Blockchain / Solidity

const contractAddress = deployedContract.[1];

Drag options to blanks, or click blank then click option'

AgetAddress

Baddress

CcontractAddress

Daddr

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method instead of a property

Using incorrect property names like 'addr' or 'contractAddress'

The deployed contract object has an address property that stores the contract's address on the blockchain.

2fill in blank

medium

Complete the code to listen for the 'Transfer' event emitted by the contract.

Blockchain / Solidity

contract.on('[1]', (from, to, amount) => { console.log(`Transfer from ${from} to ${to} of ${amount}`); });

Drag options to blanks, or click blank then click option'

AApproval

BWithdraw

CDeposit

DTransfer

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong event names like 'Deposit' or 'Withdraw'

Confusing event names with method names

The 'Transfer' event is commonly emitted when tokens move between addresses. Listening to it helps monitor contract activity.

3fill in blank

hard

Fix the error in the code to correctly fetch the transaction receipt after deployment.

Blockchain / Solidity

const receipt = await provider.getTransaction[1](txHash);

Drag options to blanks, or click blank then click option'

AReceiptSync

BReceiptAsync

CReceipt

DReceipts

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names like 'getTransactionReceipts' or adding 'Async' suffix

Misspelling 'Receipt'

The correct method to get a transaction receipt is getTransactionReceipt. It returns details about the transaction's success and events.

4fill in blank

hard

Fill both blanks to create a filter for monitoring events from a specific contract address and event name.

Blockchain / Solidity

const filter = { address: '[1]', topics: [ethers.utils.id('[2]')] };

Drag options to blanks, or click blank then click option'

A0xAbC1234567890defABC1234567890DEFabc12345

BTransfer(address,address,uint256)

CApproval(address,address,uint256)

D0x0000000000000000000000000000000000000000

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero address instead of contract address

Using wrong event signature like 'Approval' when monitoring transfers

The filter requires the contract's address and the event signature hashed as a topic. 'Transfer(address,address,uint256)' is the event signature for token transfers.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps event names to their decoded data if the event matches a filter.

Blockchain / Solidity

const decodedEvents = events.reduce((acc, event) => { if(event.event === '[1]') { acc[event.event] = [2].[3](event.data); } return acc; }, {});

Drag options to blanks, or click blank then click option'

ATransfer

BcontractInterface

CdecodeEventLog

DApproval

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong event names like 'Approval'

Calling non-existent methods on the interface

Not matching event names correctly

This code checks if the event is 'Transfer', then uses the contract interface's decodeEventLog method to decode the event data and store it in a dictionary.

Practice

1. What is the main purpose of monitoring deployed smart contracts?

easy

A. To track contract activity and events after deployment

B. To write new smart contracts

C. To compile smart contracts before deployment

D. To delete contracts from the blockchain

Solution

1. Step 1: Understand contract deployment

   Once a smart contract is deployed, it runs on the blockchain and can emit events or change state.

2. Step 2: Purpose of monitoring

   Monitoring helps track these events and state changes to stay informed and debug issues.

3. Final Answer:

   To track contract activity and events after deployment -> Option A

4. Quick Check:

   Monitoring = track activity [OK]

Hint: Monitoring means watching contract events after deployment [OK]

Common Mistakes:

• Confusing monitoring with writing or compiling contracts
• Thinking monitoring deletes contracts
• Assuming monitoring happens before deployment

2. Which of the following is the correct syntax to listen for an event named Transfer using Web3.js?

easy

A. contract.on('Transfer', callback);

B. contract.getEvent('Transfer', callback);

C. contract.listen('Transfer', callback);

D. contract.events.Transfer({}, callback);

Solution

1. Step 1: Recall Web3.js event listening syntax

   Web3.js uses contract.events.EventName(options, callback) to listen for events.

2. Step 2: Match syntax to options

   contract.events.Transfer({}, callback); matches this syntax exactly for the Transfer event.

3. Final Answer:

   contract.events.Transfer({}, callback); -> Option D

4. Quick Check:

   Web3.js event listener = contract.events.EventName [OK]

Hint: Web3.js event listeners use contract.events.EventName() [OK]

Common Mistakes:

• Using .on() which is for ethers.js, not Web3.js
• Using .listen() which is invalid
• Using .getEvent() which does not exist

3. Given this code snippet using Web3.js to fetch past events:

const events = await contract.getPastEvents('Approval', { fromBlock: 100, toBlock: 'latest' });
console.log(events.length);

What does events.length represent?

medium

A. The number of transactions in block 100

B. The number of Approval events emitted between block 100 and the latest block

C. The total number of blocks from 100 to the latest

D. The number of contracts deployed after block 100

Solution

1. Step 1: Understand getPastEvents usage

   The method fetches all events named 'Approval' emitted by the contract between specified blocks.

2. Step 2: Meaning of events.length

   The length of the returned array is the count of those events found in that block range.

3. Final Answer:

   The number of Approval events emitted between block 100 and the latest block -> Option B

4. Quick Check:

   events.length = count of fetched events [OK]

Hint: getPastEvents returns array; length = number of matching events [OK]

Common Mistakes:

• Confusing events with blocks or transactions
• Thinking length counts blocks or contracts
• Assuming it counts all events, not filtered by name

4. You wrote this code to listen for events but it never triggers:

contract.events.Transfer(callback);

What is the likely error?

medium

A. Callback function is not defined

B. Using wrong event name 'Transfer'

C. Missing empty options object before callback

D. Contract is not deployed

Solution

1. Step 1: Check Web3.js event listener syntax

   The correct syntax requires an options object before the callback, even if empty.

2. Step 2: Identify missing options object

   The code lacks the empty object {} before the callback, so the event listener does not register properly.

3. Final Answer:

   Missing empty options object before callback -> Option C

4. Quick Check:

   Event listener syntax needs options object [OK]

Hint: Always include {} before callback in Web3.js event listeners [OK]

Common Mistakes:

• Assuming event name is wrong without checking
• Ignoring syntax requirements for event listeners
• Not defining callback function properly

5. You want to monitor a deployed contract's Deposit events in real time and also fetch all past Deposit events from block 5000 onwards. Which approach correctly combines both tasks using Web3.js?

hard

A. Use contract.getPastEvents('Deposit', { fromBlock: 5000 }) for past events and contract.events.Deposit() for real-time listening

B. Use contract.events.Deposit({ fromBlock: 5000 }) for real-time and past events together

C. Use contract.events.Deposit() only, it covers past and real-time events

D. Use contract.getPastEvents('Deposit') only, it covers real-time events too

Solution

1. Step 1: Understand fetching past events

   Use getPastEvents with fromBlock to fetch historical events from a specific block.

2. Step 2: Understand real-time event listening

   Use contract.events.Deposit() without block filters to listen for new events as they happen.

3. Step 3: Combine both methods

   To monitor both past and real-time events, call getPastEvents for history, then set up events.Deposit() for live updates.

4. Final Answer:

   Use contract.getPastEvents('Deposit', { fromBlock: 5000 }) for past events and contract.events.Deposit() for real-time listening -> Option A

5. Quick Check:

   Past events + real-time = getPastEvents + events [OK]

Hint: Fetch past with getPastEvents; listen live with events.EventName() [OK]

Common Mistakes:

• Trying to get past and live events with one method
• Using events with fromBlock to get past events only
• Assuming getPastEvents listens for new events