Monitoring deployed contracts in Blockchain / Solidity

Introduction

Monitoring deployed contracts helps you know what is happening with your smart contracts after they are live. It keeps you informed about their activity and health.

You want to track transactions interacting with your smart contract.

You need to check if your contract is working as expected after deployment.

You want to get alerts if something unusual happens with your contract.

You want to gather data for analytics about contract usage.

You want to debug or troubleshoot issues in your deployed contract.

Syntax

Blockchain / Solidity

Use blockchain explorer APIs or event listeners in your code to watch contract events and transactions.

Example using Web3.js event subscription:
contract.events.EventName({fromBlock: 'latest'})
.on('data', event => console.log(event))
.on('error', console.error);

Replace EventName with the actual event your contract emits.

Listening from latest block means you only get new events after starting the listener.

Examples

This listens to all Transfer events from the start of the blockchain and logs the details.

Blockchain / Solidity

contract.events.Transfer({fromBlock: 0})
.on('data', event => console.log(event.returnValues));

This fetches past Approval events from block 1,000,000 to the latest block.

Blockchain / Solidity

contract.getPastEvents('Approval', {fromBlock: 1000000, toBlock: 'latest'})
.then(events => console.log(events));

This sets up a live subscription to new MyEvent events and logs them as they happen.

Blockchain / Solidity

const subscription = contract.events.MyEvent({fromBlock: 'latest'})
.on('data', event => {
  console.log('New event:', event);
});

Sample Program

This code connects to the Ethereum mainnet using Infura, sets up a contract instance, and listens for new Transfer events. When a transfer happens, it prints who sent tokens, who received them, and how many.

Blockchain / Solidity

import Web3 from 'web3';

const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID');
const contractAddress = '0xYourContractAddress';
const abi = [ /* contract ABI here */ ];

const contract = new web3.eth.Contract(abi, contractAddress);

contract.events.Transfer({fromBlock: 'latest'})
.on('data', event => {
  console.log(`Transfer from ${event.returnValues.from} to ${event.returnValues.to} of ${event.returnValues.value} tokens.`);
})
.on('error', console.error);

Important Notes

Make sure your contract ABI matches the deployed contract to decode events correctly.

Use reliable node providers like Infura or Alchemy to avoid missing events.

Event subscriptions may disconnect; handle reconnections in production code.

Summary

Monitoring deployed contracts lets you track contract activity in real time or from past blocks.

You can use event listeners or fetch past events using blockchain libraries like Web3.js.

This helps you stay informed, debug, and analyze your smart contracts after deployment.

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