Monitoring deployed contracts in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of monitoring deployed smart contracts?

To track contract activity, detect errors or unusual behavior, and ensure the contract operates as expected after deployment.

beginner

Name a common tool used for monitoring Ethereum smart contracts.

Etherscan is a popular blockchain explorer that allows monitoring of Ethereum smart contracts by tracking transactions and events.

intermediate

What is an event in a smart contract and why is it important for monitoring?

An event is a log emitted by a smart contract during execution. It helps external systems track contract actions without reading the entire blockchain state.

intermediate

How can alerts be set up for smart contract monitoring?

Alerts can be configured using monitoring services or custom scripts that watch for specific events or transaction patterns and notify users via email or messaging apps.

advanced

Why is it important to monitor gas usage in deployed contracts?

Monitoring gas usage helps detect inefficient contract functions or potential attacks that cause excessive costs, saving money and improving performance.

Which of the following is NOT typically monitored in deployed smart contracts?

A User's private keys

B Transaction status

C Contract events

D Gas consumption

User's private keys are private and should never be monitored or exposed by contract monitoring tools.

What does a smart contract event provide for monitoring tools?

A A way to change contract code

B Automatic contract upgrades

C Access to user wallets

D A log of specific contract actions

Events are logs emitted during contract execution that help monitoring tools track contract actions.

Which tool can you use to view transactions and events of an Ethereum contract?

A Jenkins

B GitHub

C Etherscan

D Docker

Etherscan is a blockchain explorer for Ethereum that shows transactions and contract events.

Why set up alerts in smart contract monitoring?

A To automatically update contract code

B To notify when unusual activity occurs

C To increase gas fees

D To disable the contract

Alerts notify developers or users when something unusual or important happens in the contract.

What can high gas usage in a contract indicate?

A Potential bugs or attacks

B Efficient contract execution

C Contract is paused

D User wallet balance

High gas usage may indicate inefficient code or malicious activity causing excessive costs.

Explain how monitoring events helps maintain deployed smart contracts.

Think about how events act like messages from the contract.

Describe the steps to set up an alert system for a deployed smart contract.

Consider what you want to watch and how you want to be notified.

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