Monitoring Network Validators Exits

In this tutorial, we’ll show you how to set up a Tenderly Web3 Action to monitor Lido validator exit requests and send notifications via Telegram. This project demonstrates how to use Web3 Actions to interact with smart contracts and external APIs to create a custom notification system.

Use this Github project template to set up your own monitoring of Lido validator exit requests:

Project Overview

The purpose of this project is to set up a system that monitors Lido validator exit requests and sends notifications when specific conditions are met.

Here’s a quick breakdown of the project’s flow:

1. Subscribe to relevant on-chain events: The Web3 Action listens for ValidatorExitRequest events from the Lido contract on the Ethereum mainnet.
2. Decode event using Tenderly API: When an event is detected, it retrieves the transaction details using the Tenderly API.
3. Filter for specific events of interest: The ValidatorExitRequest event is evaluated further by checking if the stakingModuleId is 1 and the nodeOperatorId is 14.
4. Respond: If ValidatorExitRequest of interest has happened, the Web3 Action sends a notification to the specified Telegram channel with details about the validator exit request.

Prerequisites

Before you begin, make sure you have the following:

• Tenderly CLI installed
• Node.js (version 16 or higher)
• npm
• A Telegram bot token and channel ID
• A Tenderly account and project

Setup

Let’s go through the steps to set up your Lido Validator Exit Notification system:

git clone https://github.com/Tenderly/tenderly-lido-validator-monitoring-solution
cd tenderly-lido-validator-monitoring-solution

npm install

account_id: "<YOUR_ACCOUNT_ID>"
actions:
  <YOUR_ACCOUNT_ID>/<YOUR_PROJECT_SLUG>:
    runtime: v2
    sources: actions
    specs:
      action_name:
        description: Get a notification when condition matches on Lido tx
        function: lidoEvents:subscribeToLidoValidatorExitRequestFn
        execution_type: parallel
        trigger:
          type: transaction
          transaction:
            status:
              - mined
            filters:
              - network: 1
                eventEmitted:
                  contract:
                    address: 0x0de4ea0184c2ad0baca7183356aea5b8d5bf5c6e
                  name: ValidatorExitRequest
project_slug: "<YOUR_PROJECT_SLUG>"

tenderly actions deploy

How it Works

Let’s break down the main components of the lidoEvents.ts file:

import { Context, TransactionEvent } from "@tenderly/actions";
import axios from "axios";
 
const subscribeToLidoValidatorExitRequestFn = async (
  context: Context,
  transactionEvent: TransactionEvent,
) => {
  // Event handling logic here
};
 
// Helper functions for API calls and notifications

The subscribeToLidoValidatorExitRequestFn function is the main entry point for our Web3 Action. It handles the following tasks:

1. Retrieves transaction details using the Tenderly API
2. Checks if the stakingModuleId is 1 and the nodeOperatorId is 14
3. If the condition is met, sends a notification to the specified Telegram channel

Tenderly API for Transaction Trace

A key part of this Web3 Action is retrieving the transaction trace using the Tenderly API. Here’s the API endpoint used:

const url = `https://api.tenderly.co/api/v1/public-contract/${network}/trace/${txHash}`;

This API endpoint returns the detailed trace of the transaction, which includes all the logs and events emitted during the transaction execution. Here’s what each part of the URL represents:

• https://api.tenderly.co/api/v1/public-contract/: The base URL for Tenderly’s public contract API
• ${network}: The network identifier (e.g., 1 for Ethereum Mainnet)
• ${txHash}: The hash of the transaction we’re interested in

The response from this API contains a wealth of information about the transaction, including:

• All emitted events and their parameters
• Internal calls made during the transaction
• State changes that occurred

In our Web3 Action, we use this trace to find the ValidatorExitRequest event and extract relevant information:

const validatorExitRequestLog = result.logs.find(
  (log: any) => log.name === "ValidatorExitRequest"
);
 
if (validatorExitRequestLog) {
  const stakingModuleId = validatorExitRequestLog.inputs.find(
    (input: any) => input.soltype.name === "stakingModuleId"
  )?.value;
  const nodeOperatorId = validatorExitRequestLog.inputs.find(
    (input: any) => input.soltype.name === "nodeOperatorId"
  )?.value;
  // ... other parameters
}

This allows us to precisely identify the validator exit requests we’re interested in and extract the necessary information to send our notification.

Customization

For Lido validator exits, events of interest are recognized by parameters stakingModuleId with value 1, and nodeOperatorId with value of 14.

To modify these filtering conditions or add more events to monitor:

1. Edit the lidoEvents.ts file
2. Update the condition check in the if statement to match your requirements
3. Modify the message format or add additional information as needed

For example, to change the stakingModuleId and nodeOperatorId conditions:

if (stakingModuleId == 1 && nodeOperatorId == 14) {
  // Your custom logic here
}

Monitoring and Troubleshooting

To ensure your Web3 Action is working correctly:

• Monitor your Web3 Action executions in the Tenderly dashboard
• Check the Tenderly logs for any error messages or execution details
• Ensure your Telegram bot has permission to send messages to the specified channel

Conclusion

You’ve now set up a custom notification system using Tenderly Web3 Actions to monitor Lido validator exit requests.