EigenLayer Operators Guide

Overview

This guide explains how operators can integrate with Byzantine's EigenLayer vaults. Operators are entities running infrastructure for decentralized networks within the EigenLayer ecosystem.

Keywords

• Operator Sets: Operator Sets are groups of operators responsible for securing an AVS (Autonomous Verifiable Service) and earning rewards. Each AVS defines one or more Operator Sets that operators can choose to join. By joining an Operator Set, operators take on the responsibility of securing the system and gain access to its rewards, as well as the risk of slashing penalties. (cf. code)

• Allocation Delay: Number of blocks required for an Operator's allocation to become active in an Operator Set for a specific Strategy.

• Deallocation Delay: Number of blocks between an operator's request to deallocate stake from an Operator Set for a strategy and the deallocation becoming effective.

• Magnitudes: Magnitude tracks Operator's allocations within Operator Sets. It represents proportions of an Operator’s stake delegations for a particular Strategy. The initial value of the total magnitude is 1x10¹⁸.

Prerequisites

• An Ethereum account (EOA) or smart contract (e.g multisig) that will act as the operator. If you don't have operator account yet, it will be possible to create the operator's keys on the step Create operator's keys

• Understanding of the following EigenLayer contracts:

  • DelegationManager

  • AllocationManager

Contract	Holesky Address	Mainnet Address
DelegationManager	0xA44151489861Fe9e3055d95adC98FbD462B948e7	0x78469728304326CBc65f8f95FA756B0B73164462
AllocationManager	0x78469728304326CBc65f8f95FA756B0B73164462	0x948a420b8CC1d6BFd0B6087C2E7c344a2CD0bc39

Integration Flow

Integration Steps

Installation

EigenLayer CLI

Find the complete guide here: https://docs.eigenlayer.xyz/operators/howto/operator-installation

System Requirements

• Docker

• Docker Compose

• Linux Environment

• Go ≥ 1.21 (if you choose to install eigenlayer-cli using the Go programming language)

Checking for requirements

To check if Docker is installed, run:

docker --version

CLI Installation

Install CLI using Binary

To install a binary inside the ~/bin directory for latest release, run:

curl -sSfL https://raw.githubusercontent.com/layr-labs/eigenlayer-cli/master/scripts/install.sh | sh -s

The binary will be installed inside the ~/bin directory. To add the binary to your path, run:

export PATH=$PATH:~/bin

Install CLI Using Go

To install the eigenlayer-CLI using Go, run:

go install github.com/Layr-Labs/eigenlayer-cli/cmd/eigenlayer@latest

To check if the GOBIN is not in your PATH, you can execute echo $GOBIN from the Terminal. If it doesn't print anything, then it is not in your PATH. To add GOBIN to your PATH, add the following lines to your $HOME/.profile:

export GOBIN=$GOPATH/bin
export PATH=$GOBIN:$PATH

Install CLI from Source

To generate the binary manually, download and compile the source code, run:

git clone https://github.com/Layr-Labs/eigenlayer-cli.git
cd eigenlayer-cli
mkdir -p build
go build -o build/eigenlayer cmd/eigenlayer/main.go

or if you have make installed, run:

git clone https://github.com/Layr-Labs/eigenlayer-cli.git
cd eigenlayer-cli
make build

The executable will be in the build folder.

In case you want the binary in your PATH (or if you used the Go method and you don't have $GOBIN in your PATH), please copy the binary to /usr/local/bin:

Byzantine SDK

System Requirements

• Node.js (v14 or higher)

• npm or yarn

• TypeScript (optional but recommended)

Installation Steps

1. Install the SDK

npm install @byzantine/operator-sdk

1. Create Environment File

If you don't yet have your operator key, you can use the eigenlayer-cli to generate one

Create a .env file in your project root:

RPC_URL=https://holesky.infura.io/v3/your_api_key_here

# Choose ONE of the following authentication methods:
MNEMONIC=your_wallet_mnemonic
# OR
PRIVATE_KEY=your_wallet_private_key_without_0x_prefix

DEFAULT_CHAIN_ID=17000  # 17000 for Holesky testnet, 1 for Ethereum Mainnet, 560048 for Hoodi Testnet

1. Basic Setup

import { ByzOperatorClient } from "@byzantine/operator-sdk";
import { ethers } from "ethers";
import * as dotenv from "dotenv";

dotenv.config();

const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
const wallet = ethers.Wallet.fromPhrase(process.env.MNEMONIC).connect(provider);
// OR const wallet = new ethers.Wallet(process.env.PRIVATE_KEY).connect(provider);

const client = new ByzOperatorClient({
  chainId: 17000, // 17000 for Holesky, 1 for Mainnet, 560048 for Hoodi
  provider: provider,
  signer: wallet,
});

Create Operator's keys using eigenlayer-cli (optional)

This section is needed only if you do not yet have an Eigen Layer operator address and keys on Ethereum.

ECDSA keypair corresponds to the operator Ethereum address and key for interacting with Eigenlayer. The BLS key is used for attestation purposes within the EigenLayer protocol. BLS key is used when you register an AVS to EigenLayer.

Find the complete guide here: https://docs.eigenlayer.xyz/operators/howto/operator-installation#create-and-list-keys

Create Keys

To generate encrypted ECDSA and BLS keys, run:

eigenlayer keys create --key-type ecdsa [keyname]
eigenlayer keys create --key-type bls [keyname]

[keyname] - This will be the name of the created key file. It will be saved as <keyname>.ecdsa.key.json or <keyname>.bls.key.json.

This will prompt a password which you can use to encrypt the keys. Keys will be stored in a local disk and will be shown once keys are created. It will also show the private key only once, so that you can back it up in case you lose the password or key file.

List Keys

To retrieve the list of the keys you have created with the EigenLayer cli tool, run:

eigenlayer keys list

Export keys

To see the private key of the existing keys, run the below command.

eigenlayer keys export --key-type ecdsa [keyname]

This will only work if your keys are in default location (~/.eigenlayer/operator_keys).

If your keys is not in the default location, you can give the full path to the key file using --key-path flag. You don't need to provide the key name in that case.

eigenlayer keys export --key-type ecdsa --key-path [path]

Import Operator's keys (optional if using Byzantine-SDK)

Find the complete guide here: https://docs.eigenlayer.xyz/operators/howto/operator-installation#import-keys

This section is needed only if you plan to follow the operators onboarding steps using the eigenlayer-cli tool

Import Keys

To import an ECDSA key on the eigenlayer-cli, run:

eigenlayer keys import --key-type ecdsa [keyname] [privatekey]

To import a BLS key, run:

eigenlayer keys import --key-type bls [keyname] [privatekey]

• [keyname] is the name of the imported key file, and it will be saved as <keyname>.ecdsa.key.json or <keyname>.bls.key.json.

• privatekey is the private key of the key you wish to import.

  • For BLS keys, it should be a large number.

  • For ECDSA keys, it should be in hex format.

1. Operator Configuration and Registration

In this section, you will register your operator Ethereum address as an Eigen Layer operator. You will have to prepare beforehand some data tied to your operator:

• a Delegation Approver: an address who approves new delegations from Stakers to this Operator. If this address is left as the zero (0x000...) then all new delegations to this operator will be automatically approved without the need for any signature. This parameter allows operators to have permissioned and approved delegations. Learn how to approve stakers' delegation

• an Allocation Delay: The number of blocks required for an Operator's allocation to become active in an Operator Set.

• a metadata URI: a URI for the operator's metadata, i.e. a link providing more details on the operator (name, website, logo, twitter, ...)

EigenLayer CLI

Find the complete guide here: https://docs.eigenlayer.xyz/operators/howto/operator-installation#operator-configuration-and-registration

Step 1: Create the config files needed for operator registration, run:

eigenlayer operator config create

When prompted for operator address, make sure your operator address is same as the ECDSA key address you created/imported in key creation steps.

The command will create two files:

• operator.yaml

• metadata.json

Step 2: Upload Logo Image and configure metadata.json

• Upload the logo of the operator (only .png file within 1MB in size) to a publicly accessible location and set the url in your metadata.json file.

• The name and description should comply with the regex mention here. You can use services like https://regex101.com/ to validate your fields.

• The metadata.json must be less than 4KB in size. Upload the file to a publicly accessible location and set that url in operator.yaml.

For Mainnet Operators - the metadata.json and operator logo.png files MUST be hosted via github.com repositories specifically. Caveat: gist.github.com hosted files are not permitted. These requirements do not apply to Testnet Operators.

An example operator.yaml file is provided for your reference here: operator.yaml.

When using Github for hosting please ensure you link to the raw file (example), rather than the github repo URL (example).

Step 3: Configure RPC Node:

The EigenLayer CLI requires access to an Ethereum RPC node in order to post registration.

Please find example lists of RPC node providers here:

• https://chainlist.org/

• https://www.alchemy.com/list-of/rpc-node-providers-on-ethereum

Ensure that your Operator server can reach your RPC provider at this point. You may run the following command from your Operator server: curl -I [your_server_url]

Step 4: DelegationManager Contract Address

You must configure the correct DelegationManager contract address for your environment.

• Navigate to EigenLayer Contracts: Deployments and locate the Proxy address for DelegationManager for your environment (Mainnet, Testnet).

• Set the value for el_delegation_manager_address in your operator.yaml config file to the address for your environment.

Optional: Set Delegation Approver

Operators have the option to set delegationApprover when they register. If the delegationApprover is set to a nonzero value, then the delegationApprover address will be required sign its approval of new delegations from Stakers to this Operator. If the default value is left as the zero address (0x000...) then all new delegations will be automatically approved without the need for any signature. Please see delegationApprover Design Patterns for more detail.

Step 5: Registration Command

To register your operator, run:

eigenlayer operator register operator.yaml

ECDSA key is required for operator registration. You may choose to either:

• create your own set of keys using the EigenLayer CLI (if you have not previously created keys).

• import your existing keys (if you have previously created keys).

Byzantine SDK

Coming soon...

2. Allocation and Registration to Operator Sets

EigenLayer CLI

Find the complete guide here: https://docs.eigenlayer.xyz/operators/howto/operator-sets

If you are using the eigenlayer-cli you must check that the --caller-address has been imported or created on the cli environment

If not already done, set the Allocation Delay by running:

If you have registered your operator by following the previous instructions, the allocation is already set, so no need to run the following command.

eigenlayer operator allocations set-delay <flags> <allocation-delay>

To register to Operator Set, run:

eigenlayer operator register-operator-sets 
	--operator-address <operator-address> 
	--avs-address <avs-service-manager-address> 
	--operator-set-ids <comma-separated-list-of-operator-set-ids>
	--caller-address <address-of-caller>

To Set Allocations per Operator Set and Strategy, run:

eigenlayer operator allocations update 
	--network sepolia
	--operator-address <operator-address> 
	--csv-file updates.csv 
	--caller-address <address-of-caller>

Use the csv in the below format to set multiple allocations in one transaction, where update.csv will look like:

avs_address,operator_set_id,strategy_address,bips
0x2222AAC0C980Cc029624b7ff55B88Bc6F63C538f,2,0x4936BA8f0a04CcC2e49b8C9E42448c5cD04bF3f5,1200
0x2222AAC0C980Cc029624b7ff55B88Bc6F63C538f,1,0x4936BA8f0a04CcC2e49b8C9E42448c5cD04bF3f5,165

bips is the percentage of delegated stake an operator decides to allocate to an operator set (1000 bips = 10%, 10000 bips = 100%)

To view all your allocations, run:

eigenlayer operator allocations show 
	--network sepolia
	--operator-address <operator-address> 
	--strategy-addresses <comma-separated-strategy-addresses>

To de-register from Operator Sets, run:

eigenlayer operator deregister-operator-sets 
	--operator-address <operator-address> 
	--avs-address <avs-address> 
	--operator-set-ids <comma-separated-list-of-operator-set-ids>
	--caller-address <address-of-caller>

If you are deregistering from an operator set which has some active allocation bips, you will have to explicitly deallocate from that operator set using the `eigenlayer operator allocations update` command specified above. If you don’t do this, that amount of stake would be unavailable until it is deallocated. Once you deallocate then after deallocation delay it will be available.

Byzantine SDK

Coming soon...

3. Run the node

Now that you've opted in to EigenLayer and received delegation to one or more AVSs, you're ready to actually run the infrastructure that powers these services, and start earning rewards.

Each AVS in the EigenLayer ecosystem has its own setup process and technical requirements.

To help you get started, we've put together a table listing supported AVSs along with direct links to their operator documentation.

👉 Click here to access the full list of AVS node setup guides

Metadata Updates

Registered operators can update their metadata (if they change their restaking strategy or update their website)

EigenLayer CLI

This is the command you can use to make changes or updates to the metadata of your operator.

eigenlayer operator update-metadata-uri operator.yaml

Byzantine SDK

Coming soon...