Skip to content

0_running_an_operator.md

Latest commit

 

History

History
328 lines (210 loc) · 10.3 KB

0_running_an_operator.md

File metadata and controls

328 lines (210 loc) · 10.3 KB

Register as an Aligned operator in testnet

CURRENT VERSION: Aligned Operator v0.20.0

IMPORTANT: You must be whitelisted to become an Aligned operator.

Requirements

This guide assumes you are already registered as an operator with EigenLayer.

Hardware Requirements

Minimum hardware requirements:

Component Specification
CPU 16 cores
Memory 32 GB RAM
Bandwidth 1 Gbps
Storage 256 GB disk space

Supported Strategies

The list of supported strategies can be found here.

Step 1 - Clone the repo

To start with, clone the Aligned repository and move inside it

git clone https://github.com/yetanotherco/aligned_layer.git --branch v0.20.0
cd aligned_layer

Step 2 - Building the Operator

Ensure you have the following installed:

Also, you have to install the following dependencies for Linux:

  • pkg-config
  • libssl-dev
  • g++

To install foundry, run:

make foundry_install
foundryup

To build the operator binary for Hoodi or Sepolia, run:

make operator_build ENVIRONMENT=testnet

To build the operator binary for Mainnet, run:

make operator_build ENVIRONMENT=mainnet

Upgrading the Operator

If you want to upgrade the operator in Hoodi or Sepolia, run:

make operator_update ENVIRONMENT=testnet

If you want to upgrade the operator in Mainnet, run:

make operator_update ENVIRONMENT=mainnet

This will recreate the binaries. You can then proceed to restart the operator.

You can find the latest version of the operator here.

Checking the Operator Version

To see the operator version, run:

./operator/build/aligned-operator --version

This will display the current version of the operator binary.

Step 3 - Update the configuration for your specific Operator

Locate the appropiate operator_config_file:

  • Mainnet: ./config-files/config-operator-mainnet.yaml.
  • Sepolia: ./config-files/config-operator-sepolia.yaml.
  • Hoodi: ./config-files/config-operator-hoodi.yaml.

Update the following placeholders:

  • "<operator_address>"
  • "<earnings_receiver_address>"
  • "<ecdsa_key_store_location_path>"
  • "<ecdsa_key_store_password>"
  • "<bls_key_store_location_path>"
  • "<bls_key_store_password>"

"<ecdsa_key_store_location_path>" and "<bls_key_store_location_path>" are the paths to your keys generated with the EigenLayer CLI, "<operator_address>" and "<earnings_receiver_address>" can be found in the operator.yaml file created in the EigenLayer registration process.

The keys are stored by default in the ~/.eigenlayer/operator_keys/ directory, so for example <ecdsa_key_store_location_path> could be /path/to/home/.eigenlayer/operator_keys/some_key.ecdsa.key.json and for <bls_key_store_location_path> it could be /path/to/home/.eigenlayer/operator_keys/some_key.bls.key.json.

{% hint style="danger" %}

Don't keep the Operator Key in the Aligned Operator Node. If you already registered, don't use it. If you need to register, delete it after step 4.

{% endhint %}

The ECDSA key is only used for registration and funding of the operator and is not needed afterwards. It is recommended that you remove it after you're done, as well as the ecdsa section in the config file, or better yet for that data to never make it to the server (e.g., you run the registration from a machine without listening ports).
If you run the registration on the server, it's recommended to do this part on a RAM filesystem to ease secure removal, and only after removing the ecdsa section move the config file to persistent storage.

If you run on a different computer, you will need to copy the BLS key store to the server.

Two RPCs are used, one as the main one, and the other one as a fallback in case one node is working unreliably.

Default configurations is set up to use the same public node in both scenarios.

{% hint style="danger" %}

PUBLIC NODES SHOULDN'T BE USED AS THE MAIN RPC. We recommend not using public nodes at all.

FALLBACK AND MAIN RPCs SHOULD BE DIFFERENT.

{% endhint %}

Most of the actions will pass through the main RPC unless there is a problem with it. Events are fetched from both nodes.

eth_rpc_url: "https://<RPC_1>" 
eth_rpc_url_fallback: "https://<RPC_2>"
eth_ws_url: "wss://<RPC_1>"
eth_ws_url_fallback: "wss://<RPC_2>"

Step 4 - Register Operator on AlignedLayer

Then you must register as an Operator on AlignedLayer. To do this, you must run:

  • Mainnet:

    make operator_register_with_aligned_layer CONFIG_FILE=./config-files/config-operator-mainnet.yaml

  • Sepolia:

    make operator_register_with_aligned_layer CONFIG_FILE=./config-files/config-operator-sepolia.yaml

  • Hoodi:

    make operator_register_with_aligned_layer CONFIG_FILE=./config-files/config-operator-hoodi.yaml

{% hint style="danger" %} If you are going to run the server in this machine, delete the operator key {% endhint %}

Step 5 - Start the operator

  • Mainnet:

    ./operator/build/aligned-operator start --config ./config-files/config-operator-mainnet.yaml

  • Sepolia:

    ./operator/build/aligned-operator start --config ./config-files/config-operator-sepolia.yaml

  • Hoodi:

    ./operator/build/aligned-operator start --config ./config-files/config-operator-hoodi.yaml

Run Operator using Systemd

To manage the Operator process on Linux systems, we recommend use systemd with the following configuration:

You should create a user and a group in order to run the Operator and set the service unit to use that. In the provided service unit, we assume you have already created a user called aligned

# aligned-operator.service

[Unit]
Description=Aligned Operator
After=network.target

[Service]
Type=simple
User=aligned
ExecStart=<path_to_aligned_layer_repository>/operator/build/aligned-operator start --config <path_to_operator_config_file>
Restart=always
RestartSec=1
StartLimitBurst=100

[Install]
WantedBy=multi-user.target

{% hint style="info" %} aligned-operator.service is just an arbitrary name. You can name your service as you wish, following the format <service-name>.service. {% endhint %}

Once you have configured the aligned-operator.service file, you need to run the following commands:

sudo cp aligned-operator.service /etc/systemd/system/aligned-operator.service
sudo systemctl enable --now aligned-operator.service

{% hint style="warning" %} All paths must be absolute. {% endhint %}

Those commands will link the service to systemd directory and then, will start the Operator service.

Also, if the server running the operator goes down, systemd will start automatically the Operator on server startup.

Restart operator

If you want to restart the operator, you can use the following command:

sudo systemctl restart aligned-operator.service

Get Operators logs

Once you are running your operator using systemd, you can get its logs using journalctl as follows:

journalctl -xfeu aligned-operator.service

Operator Metrics

Metrics are exposed by default at localhost:9092/metrics in Prometheus format. To change the endpoint, update the following line in the configuration file:

metrics_ip_port_address: localhost:9092

Example of exposed metrics:

# HELP aligned_operator_responses_count Number of proof verified by the operator and sent to the Aligned Service Manager
# TYPE aligned_operator_responses_count counter
aligned_operator_responses_count x

You can scrape these metrics using Prometheus and visualize them in Grafana or configure alerts based on the data.

Unregistering the operator

To unregister the Aligned operator, run:

  • Mainnet:

    cast send --rpc-url https://ethereum-rpc.publicnode.com --private-key <private_key> 0xA8CC0749b4409c3c47012323E625aEcBA92f64b9 'deregisterOperator(bytes)' 0x00

  • Sepolia:

    cast send --rpc-url https://ethereum-sepolia-rpc.publicnode.com --private-key <private_key> 0x0Ef1920F089DD02d3A28BF2e34342FD3e74160A3 'deregisterOperator(bytes)' 0x00

  • Hoodi:

    cast send --rpc-url https://ethereum-hoodi-rpc.publicnode.com --private-key <private_key> 0xD06AAf23d136ECBfb5Bdb349Dd7a87aDc74673Dd 'deregisterOperator(bytes)' 0x00

<private_key> is the one specified in the output when generating your keys with the EigenLayer CLI.

Deposit Strategy Tokens in Hoodi

You can restake stETH as the strategy token.

You will need to stake a minimum of 1000 WEI in stETH. We recommend to stake a maximum amount of 10 stETH. If you are staking more than 10 stETH please unstake any surplus over 10.

If you already have ETH and need to convert it to stETH, you can get it from Lido Website.

Finally, to end the staking process, you need to deposit into the stETH strategy,

There are two options, either doing it through EigenLayer's website, or running the commands specified by us below.

Option 1

To restake through EigenLayer's website, go to stETH strategy.

Option 2

To deposit one stETH using the Operator CLI, run the following command:

./operator/build/aligned-operator deposit-into-strategy --config ./config-files/config-operator.yaml --strategy-address 0x19536FAd6Eb831e8211B316177979161BBdb2c2B --amount 1000000000000000000

Where 0x19536FAd6Eb831e8211B316177979161BBdb2c2B is the stETH strategy address in Hoodi.

If you don't have Hoodi ETH, these are some useful faucets: