LogoLogo
SDKAPI
Next
Next
  • Learn
    • Introduction
      • Obol Collective
      • OBOL Incentives
      • Key Staking Concepts
      • Obol vs Other DV Implementations
      • Obol Splits
      • DV Launchpad
      • Frequently Asked Questions
    • Charon
      • Introduction to Charon
      • Distributed Key Generation
      • Cluster Configuration
      • Charon Networking
      • CLI Reference
    • Futher Reading
      • Ethereum and Its Relationship With DVT
      • Community Testing
      • Peer Score
      • Useful Links
  • Run a DV
    • Quickstart
      • Quickstart Overview
      • Create a DV Alone
      • Create a DV With a Group
      • Push Metrics to Obol Monitoring
    • Prepare to Run a DV
      • How and Where To Run DVs
      • Deployment Best Practices
      • Test a Cluster
    • Running a DV
      • Activate a DV
      • Update a DV
      • Monitoring Your Node
      • Claim Rewards
      • Exit a DV
    • Partner Integrations
      • Create an EigenLayer DV
      • Create a Lido CSM DV
      • DappNode
  • Advanced & Troubleshooting
    • Advanced Guides
      • Create a DV Using the SDK
      • Migrate an Existing Validator
      • Enable MEV
      • Combine DV Private Key Shares
      • Self-Host a Relay
      • Advanced Docker Configs
      • Beacon node authentication
    • Troubleshooting
      • Errors & Resolutions
      • Handling DKG Failure
      • Client Configuration
      • Test Commands
    • Security
      • Overview
      • Centralization Risks and Mitigation
      • Obol Bug Bounty Program
      • Smart Contract Audit
      • Software Development at Obol
      • Charon Threat Model
      • Contacts
  • Community & Governance
    • Governance
      • Collective Overview
      • The Token House
      • The RAF
      • The OBOL Token
      • Delegate Guide
      • RAF1 Guide
    • Community
      • Staking Mastery Program
      • Techne
    • Contribution & Feedback
      • Filing a Bug Report
      • Documentation Standards
      • Feedback
  • Walkthrough Guides
    • Walkthroughs
      • Walkthrough Guides
  • SDK
    • Intro
    • Enumerations
      • FORK_MAPPING
    • Classes
      • Client
    • Interfaces
      • ClusterDefinition
      • RewardsSplitPayload
    • Type-Aliases
      • BuilderRegistration
      • BuilderRegistrationMessage
      • ClusterCreator
      • ClusterLock
      • ClusterOperator
      • ClusterPayload
      • ClusterValidator
      • DepositData
      • DistributedValidator
      • ETH_ADDRESS
      • OperatorPayload
      • SplitRecipient
      • TotalSplitPayload
    • Functions
      • validateClusterLock
  • API
    • What is this API?
    • System
    • Metrics
    • Cluster Definition
    • Cluster Lock
    • State
    • DV Exit
    • Cluster Effectiveness
    • Terms And Conditions
    • Techne Credentials
    • Address
    • OWR Information
  • Specification
Powered by GitBook
On this page
  • Getting started
  • Part 1: Creating the Cluster SAFE + Splitter Contract
  • Deploy the SAFE
  • Deploy the Splitter Contract
  • Part 2: Use the DV Launchpad + CLI to create the cluster keys
  • Step 1: Clone the repo
  • Step 2: Create ENR and Backup your Private Key
  • Back up the private key located in .charon/charon-enr-private-key
  • Step 3: Create the DV cluster configuration using the Launchpad
  • Step 4: Distributed Key Generation (DKG)
  • Step 5: Create a .env file for Mainnet
  • Step 6: Starting the Node
  • Part 3: Upload the public keys and deposit to Lido CSM
Edit on GitHub
  1. Run a DV
  2. Partner Integrations

Create a Lido CSM DV

Setup and run a DV within the Lido Community Staking Module

PreviousCreate an EigenLayer DVNextDappNode

Last updated 10 days ago

This is a guide on taking part in Lido's (CSM) with a squad as part of a .

To start, this guide makes a couple assumptions:

  1. You're running a Linux distribution and you've installed and (as a ).

  2. You will be deploying on Ethereum mainnet. Some screenshots in this guide are from Holesky just for demonstration purposes, so please verify you are using the correct .

Getting started

This guide is broken down into 3 parts:

Part 1: Creating a shared wallet for the cluster, and a reward splitting contract

Part 2: Using the + CLI to create the cluster

Part 3: Deploying the validator to Lido's CSM using their UI.

In this guide we'll be using CSM UI in advanced mode, using the extendedManagerPermissions to set the managerAddress to the cluster multi-sig (SAFE) and the rewardAddress to the Splits.org splitting contract.

Part 1: Creating the Cluster SAFE + Splitter Contract

Deploy the SAFE

Detailed instructions on how to create a SAFE Wallet can be found .

The squad leader should obtain signing addresses for all the cluster members, to create a new SAFE with the operators all as owners.

After giving the Safe a name and selecting the appropriate network, continue by clicking the Next button.

Add all the signer addresses of the cluster members, select a threshold, and proceed to the final step by clicking the Next button.

Finally, submit the transaction to create the Safe by clicking on the Create button.

Deploy the Splitter Contract

The squad leader should obtain the reward addresses from all the cluster members (if members want to use a distinct address to the one they sign with for receiving rewards). Open https://app.splits.org and create a New contract. Make sure to select the appropriate network.

Select Split for the contract type.

Finally, click the Create Split button, execute the transaction and share the created split contract with all cluster members for review.

Part 2: Use the DV Launchpad + CLI to create the cluster keys

Step 1: Clone the repo

git clone https://github.com/ObolNetwork/charon-distributed-validator-node.git

Step 2: Create ENR and Backup your Private Key

Enter the CDVN directory:

cd charon-distributed-validator-node

Use docker to create an ENR

docker run --rm -v "$(pwd):/opt/charon" obolnetwork/charon:v1.4.0 create enr

Back up the private key located in .charon/charon-enr-private-key

What you see in the console starting with enr:- is the public key for your Charon node (known as an ENR). The private key is in the file .charon/charon-enr-private-key, be sure to back it up securely.

Step 3: Create the DV cluster configuration using the Launchpad

Obol has integrated a CSM details into the DV Launchpad. Choosing the "Lido CSM" withdrawal configuration allows you to create up to 12 validator keys (CSM's Early Access limit) with Lido's required withdrawal and fee recipient addresses.

Then click Get Started.

Accept all the necessary advisories and sign to confirm.

Cluster configuration begins next. First, select the cluster name and size, then enter all cluster members signer addresses.

  • Select the number of validators to create.

  • Finally, click on the Create Cluster Configuration button.

Lastly, share the cluster invite link with the other cluster members.

Step 4: Distributed Key Generation (DKG)

Once all members confirm the configuration they will see the Continue button.

On the next page, they will find a CLI command which is used to begin the Distributed Key Generation (DKG) ceremony. All members need to synchronously complete this step.

Go back to the terminal and make sure you're in the charon-distributed-validator-node directory before running the DKG command:

pwd

If you are not, navigate to it using the cd command.

Paste the DKG command into your terminal and wait for all the other squad members to connect and complete the DKG ceremony.

New files were generated: cluster-lock.json, deposit-data.json, validator_keys are all found in the .charon folder (hidden by default). This contains each operator's partial key signatures for the validators.

At this point, each operator must make a backup of the .charon folder and keep it safe, as validator keys cannot be recreated if lost.

Step 5: Create a .env file for Mainnet

Copy and rename the .env.sample.mainnet file to .env

cp .env.sample.mainnet .env

Open the .env file using you favourite editor:

nano .env

Uncomment and set BUILDER_API_ENABLED=true.

Step 6: Starting the Node

Each cluster member should start the node with the following command:

docker compose up -d

At this point, execution and consensus clients should start syncing. Charon and the validator client should start waiting for the consensus client to be synced and the validator to be activated.

Part 3: Upload the public keys and deposit to Lido CSM

CSM is launching with a whitelisted set of approved operators (Early Access). The squad member with EA should be the one to create the node through the CSM widget.

The EA member clicks on the Create Node Operator button.

  • The EA member pastes the contents of the deposit-data.json file into the Upload deposit data field. The EA member should have enough ETH/stETH/wstETH to cover the bond.

  • Expand the Specify custom addresses section.

    • Verify that the Extended box is outlined. This ensures that the Safe address has the ability to change the reward address if necessary.

  • Check that the correct addresses are set and click the Create Node Operator button.\

Sign the transaction. The cluster is ready for deposit from Lido CSM. At this point, your job is finished.

Don't require 100% of signers to approve transactions, in case someone loses access to their address. Using the same as your cluster will use is a reasonable starting point.

Add the reward addresses of all cluster members. Choose whether the contract is immutable (reccommended option), whether to sponsor the maintainers of , and optionally whether to set a distribution bounty such that third parties could pay the gas costs of distributing the accrued rewards in exchange for a small fee.

If your cluster would like to contribute a portion of its rewards to Obol’s '' Retroactive Fund, thereby earning as part of Lido's into the DV Vault, you must add as a recipient of 0.1% of the splitter contract. This will contribute 0.1% of rewards and your CSM bond to Obol's RAF. Future versions of CSM integrations will enable contributing exactly 1% of accruing CSM rewards

Charon is the middleware client that enables validators to be run by a group of independent node operators - a cluster or squad. A complete multi-container Docker setup including execution client, consensus client, validator client, MEV-Boost, the Charon client and monitoring tools can be found in .

To start, the squad leader opens the , then connects their wallet and chooses Create a cluster with a group.

(If the cluster creator is taking part in the cluster) Enter your Charon node's ENR which was generated during above.

In the Withdrawal Configuration field, select LIDO CSM. This will automatically fill the required Withdrawal Address and Fee Recipient Addresss per .

All squad members need to open the cluster invitation link, connect their wallet, accept all necessary advisories, and to verify the cluster configuration is correct with a signature. Each squad member will also need to upload and sign an ENR to represent their charon client, so see and above.

Uncomment MEVBOOST_RELAYS= and set it to the URL of at least one of Lido's approved MEV relays . Multiple relays must be separated by a comma. Consult our for further info on MEV relay selection.

The EA member will head to and connect their wallet. (Note the mode=extended parameter.) This allows the Lido CSM reward address to be set to the split contract created earlier.

Set the Reward Address field to the Split contract address and the Manager Address field to the Safe wallet address. (These were created previously in )

When claiming your cluster's rewards, be sure to claim in wstETH. Claiming native ETH will result in loss of funds. Rebasing tokens like stETH may not receive the incremental yield you’re expecting. More information can be found in the .

splits.org
1% for Decentralisation
Obol Contributions
integration of CSM
retroactivefunding.obol.eth
this repository
DV Launchpad
Lido's Documentation
CSM Extended Mode
splits.org documentation
step 2
steps 1
2
part 1
Community Staking Module
Git
Docker
non-root user
mainnet addresses
SAFE
Splits.org
Obol DV Launchpad
here
here
threshold
Distributed Validator Cluster
deployment best practices