feat (operator): Dockerfile (#378)

Co-authored-by: JuArce <[email protected]>
Co-authored-by: Santos Rosati <[email protected]>
Co-authored-by: Tatu <[email protected]>
Co-authored-by: Urix <[email protected]>

Author: 4 people

Makefile

@@ -154,6 +154,10 @@ operator_deposit_and_register: operator_deposit_into_strategy operator_register_
 
 operator_full_registration: operator_get_eth operator_register_with_eigen_layer operator_mint_mock_tokens operator_deposit_into_mock_strategy operator_whitelist_devnet operator_register_with_aligned_layer
 
+operator_start_docker:
+	@echo "Starting Operator..."
+	@docker-compose -f operator/docker/compose.yaml up
+
 __BATCHER__:
 
 BURST_SIZE=5
@@ -651,7 +655,7 @@ build_all_ffi: ## Build all FFIs
 build_all_ffi_macos: ## Build all FFIs for macOS
 	@echo "Building all FFIs for macOS..."
 	@$(MAKE) build_sp1_macos
-	@$(MAKE) build_risc_zero_macos
+#	@$(MAKE) build_risc_zero_macos
 #	@$(MAKE) build_merkle_tree_macos
 	@$(MAKE) build_halo2_ipa_macos
 	@$(MAKE) build_halo2_kzg_macos
@@ -660,7 +664,7 @@ build_all_ffi_macos: ## Build all FFIs for macOS
 build_all_ffi_linux: ## Build all FFIs for Linux
 	@echo "Building all FFIs for Linux..."
 	@$(MAKE) build_sp1_linux
-	@$(MAKE) build_risc_zero_linux
+#	@$(MAKE) build_risc_zero_linux
 #	@$(MAKE) build_merkle_tree_linux
 	@$(MAKE) build_halo2_ipa_linux
 	@$(MAKE) build_halo2_kzg_linux

README.md

@@ -156,16 +156,17 @@ This guide assumes you are already [registered as an operator with EigenLayer](h
 Minimum hardware requirements:
 
 | Component     | Specification     |
-| ------------- | ----------------- |
+|---------------|-------------------|
 | **CPU**       | 16 cores          |
 | **Memory**    | 32 GB RAM         |
 | **Bandwidth** | 1 Gbps            |
 | **Storage**   | 256 GB disk space |
 
-#### Software Requirements
+### Dependencies
 
-Ensure you have the following installed:
+#### From Source (Recommended)
 
+Ensure you have the following installed:
 - [Go](https://go.dev/doc/install)
 - [Rust](https://www.rust-lang.org/tools/install)
 - [Foundry](https://book.getfoundry.sh/getting-started/installation)
@@ -182,35 +183,49 @@ make install_foundry
 foundryup
 ```
 
-#### Install the Operator Binary
+#### Using Docker
 
-To install the operator binary, run:
-
-```bash
-make build_operator
-```
+Ensure you have the following installed:
+- [Docker](https://docs.docker.com/get-docker/)
+- [Docker Compose](https://docs.docker.com/compose/install/)
 
-#### Update the operator
+### Configuration
 
-To update the operator, first stop the process running the operator (if there is any) and then run:
-
-```bash
-git pull
-make build_operator
-```
-
-#### Configuration
+#### From source (Recommended)
 
 Update the following placeholders in `./config-files/config-operator.yaml`:
-
-- `"<ecdsa_key_store_location_path>"`
-- `"<bls_key_store_location_path>"`
 - `"<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`.
 
+#### Using docker
+
+Update the following placeholders in `./config-files/config-operator.docker.yaml`:
+- `"<operator_address>"`
+- `"<earnings_receiver_address>"`
+- `"<ecdsa_key_store_password>"`
+- `"<bls_key_store_password>"`
+
+Make sure not to update the `ecdsa_key_store_location_path` and `bls_key_store_location_path`
+as they are already set to the correct path.
+
+Then create a .env file in `operator/docker/.env`.
+An example of the file can be found in `operator/docker/.env.example`.
+
+The file should contain the following variables:
+
+| Variable Name               | Description                                                                                                   |
+|-----------------------------|---------------------------------------------------------------------------------------------------------------|
+| `ECDSA_KEY_FILE_HOST`       | Absolute path to the ECDSA key file. If generated from Eigen cli it should be in ~/.eigenlayer/operator_keys/ |
+| `BLS_KEY_FILE_HOST`         | Absolute path to the BLS key file. If generated from Eigen cli it should be in ~/.eigenlayer/operator_keys/   |
+| `OPERATOR_CONFIG_FILE_HOST` | Absolute path to the operator config file. It should be path to config-files/config-operator.docker.yaml      |
+
 ### Deposit Strategy Tokens
 
 We are using [WETH](https://holesky.eigenlayer.xyz/restake/WETH) as the strategy token.
@@ -223,39 +238,45 @@ You will need to stake a minimum of a 1000 Wei in WETH. We recommend to stake a
 EigenLayer's guide can be found [here](https://docs.eigenlayer.xyz/eigenlayer/restaking-guides/restaking-user-guide/liquid-restaking/restake-lsts).
 
 #### Option 2:
-If you have ETH and need to convert it to WETH you can use the following command, that will convert 1 Eth to WETH. Change the parameter in ```---value``` if you want to wrap a different amount:
+If you have ETH and need to convert it to WETH you can use the following command, that will convert 1 Eth to WETH.
+Make sure to have [foundry](https://book.getfoundry.sh/getting-started/installation) installed.
+Change the parameter in ```---value``` if you want to wrap a different amount:
 
 ```bash
 cast send 0x94373a4919B3240D86eA41593D5eBa789FEF3848 --rpc-url https://ethereum-holesky-rpc.publicnode.com --private-key <private_key> --value 1ether
 ```
 
 Here `<private_key>` is the placeholder for the ECDSA key specified in the output when generating your keys with the EigenLayer CLI.
 
-Finally, to end the staking process, you need to deposit into the strategy, as shown in EigenLayer's guide, or alternatively, you can run the following command to deposit 1 WETH:
+Finally, to end the staking process, you need to deposit into the WETH strategy,
+as shown in the Eigen guide.
 
-```bash
-./operator/build/aligned-operator deposit-into-strategy --config ./config-files/config-operator.yaml --strategy-address 0x80528D6e9A2BAbFc766965E0E26d5aB08D9CFaF9 --amount 1000000000000000000
-```
+<details>
+  <summary>An alternative using the CLI (only when running without docker)</summary>
+
+  Run the following command to deposit one WETH
+  ```bash
+  ./operator/build/aligned-operator deposit-into-strategy --config ./config-files/config-operator.yaml --strategy-address 0x80528D6e9A2BAbFc766965E0E26d5aB08D9CFaF9 --amount 1000000000000000000
+  ```
+</details>
 
 If you don't have Holesky Eth, these are some useful faucets:
 
 - [Google Cloud for Web3 Holesky Faucet](https://cloud.google.com/application/web3/faucet/ethereum/holesky)
 - [Holesky PoW Faucet](https://holesky-faucet.pk910.de/)
 
-### Register as an operator with Aligned
+### Start the operator
 
-To register the operator with Aligned, run:
+#### From Source (Recommended)
 
-```bash
-./operator/build/aligned-operator register --config ./config-files/config-operator.yaml
+```
+./operator/build/aligned-operator start --config ./config-files/config-operator.yaml
 ```
 
-### Start the operator
-
-To start the Aligned operator, run:
+#### Using Docker
 
 ```bash
-./operator/build/aligned-operator start --config ./config-files/config-operator.yaml
+make operator_start_docker
 ```
 
 ### Unregister the operator from Aligned

anvil.Dockerfile

@@ -0,0 +1,13 @@
+# Use the latest foundry image
+FROM debian:bookworm-slim
+
+RUN  apt-get update;  apt-get -y install curl ; apt-get install make
+# Copy our source code into the container
+COPY Makefile Makefile
+
+
+ENTRYPOINT ["tail", "-f", "/dev/null"]
+
+#RUN curl -L https://foundry.paradigm.xyz | bash
+#RUN source /home/ubuntu/.bashrc
+#ENTRYPOINT ["make", "anvil_start_with_block_time"]

compose.yaml

@@ -0,0 +1,8 @@
+services:
+  anvil_blockchain:
+    image: anvil_blockchain
+    build:       
+      context: .
+      dockerfile: anvil.Dockerfile
+    ports:
+      - "8000:5000"

config-files/config-operator.docker.yaml

@@ -0,0 +1,30 @@
+# Common variables for all the services
+# 'production' only prints info and above. 'development' also prints debug
+environment: "production"
+aligned_layer_deployment_config_file_path: "/usr/src/app/contracts/script/output/holesky/alignedlayer_deployment_output.json"
+eigen_layer_deployment_config_file_path: "/usr/src/app/contracts/script/output/holesky/eigenlayer_deployment_output.json"
+eth_rpc_url: "https://ethereum-holesky-rpc.publicnode.com"
+eth_ws_url: "wss://ethereum-holesky-rpc.publicnode.com"
+eigen_metrics_ip_port_address: "localhost:9090"
+
+## ECDSA Configurations
+ecdsa:
+  private_key_store_path: "/usr/src/config/operator.ecdsa.key.json"
+  private_key_store_password: "<ecdsa_key_store_password>"
+
+## BLS Configurations
+bls:
+  private_key_store_path: "/usr/src/config/operator.bls.key.json"
+  private_key_store_password: "<bls_key_store_password>"
+
+## Operator Configurations
+operator:
+  aggregator_rpc_server_ip_port_address: aggregator.alignedlayer.com:8090
+  address: "<operator_address>"
+  earnings_receiver_address: "<earnings_receiver_address>" #Can be the same as the operator.
+  delegation_approver_address: "0x0000000000000000000000000000000000000000"
+  staker_opt_out_window_blocks: 0
+  metadata_url: "https://yetanotherco.github.io/operator_metadata/metadata.json"
+  enable_metrics: true
+  metrics_ip_port_address: localhost:9092
+  max_batch_size: 268435456 # 256 MiB

config-files/config-operator.yaml

@@ -10,12 +10,12 @@ eigen_metrics_ip_port_address: "localhost:9090"
 ## ECDSA Configurations
 ecdsa:
   private_key_store_path: "<ecdsa_key_store_location_path>"
-  private_key_store_password: ""
+  private_key_store_password: "<ecdsa_key_store_password>"
 
 ## BLS Configurations
 bls:
   private_key_store_path: "<bls_key_store_location_path>"
-  private_key_store_password: ""
+  private_key_store_password: "<bls_key_store_password>"
 
 ## Operator Configurations
 operator:

operator/cmd/actions/register.go

@@ -2,13 +2,11 @@ package actions
 
 import (
 	"context"
-	"math/big"
+	operator "github.com/yetanotherco/aligned_layer/operator/pkg"
 	"time"
 
-	"github.com/Layr-Labs/eigensdk-go/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/urfave/cli/v2"
-	"github.com/yetanotherco/aligned_layer/core/chainio"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
 
@@ -35,46 +33,11 @@ func registerOperatorMain(ctx *cli.Context) error {
 
 	copy(salt[:], crypto.Keccak256([]byte("churn"), []byte(time.Now().String()), quorumNumbers, privateKeyBytes))
 
-	expiry := big.NewInt(time.Now().Add(10 * time.Minute).Unix())
-	quorumNumbersArr := types.QuorumNums{0}
-	socket := "Not Needed"
-
-	err := registerOperator(context.Background(), config,
-		socket, quorumNumbersArr, salt, expiry)
+	err := operator.RegisterOperator(context.Background(), config, salt)
 	if err != nil {
 		config.BaseConfig.Logger.Error("Failed to register operator", "err", err)
 		return err
 	}
 
 	return nil
 }
-
-// RegisterOperator operator registers the operator with the given public key for the given quorum IDs.
-// RegisterOperator registers a new operator with the given public key and socket with the provided quorum ids.
-// If the operator is already registered with a given quorum id, the transaction will fail (noop) and an error
-// will be returned.
-func registerOperator(
-	ctx context.Context,
-	configuration *config.OperatorConfig,
-	socket string,
-	quorumNumbers types.QuorumNums,
-	operatorToAvsRegistrationSigSalt [32]byte,
-	operatorToAvsRegistrationSigExpiry *big.Int,
-) error {
-	writer, err := chainio.NewAvsWriterFromConfig(configuration.BaseConfig, configuration.EcdsaConfig)
-	if err != nil {
-		configuration.BaseConfig.Logger.Error("Failed to create AVS writer", "err", err)
-		return err
-	}
-
-	_, err = writer.RegisterOperatorInQuorumWithAVSRegistryCoordinator(ctx, configuration.EcdsaConfig.PrivateKey,
-		operatorToAvsRegistrationSigSalt, operatorToAvsRegistrationSigExpiry, configuration.BlsConfig.KeyPair,
-		quorumNumbers, socket)
-
-	if err != nil {
-		configuration.BaseConfig.Logger.Error("Failed to register operator", "err", err)
-		return err
-	}
-
-	return nil
-}

operator/docker/.env.example

@@ -0,0 +1,3 @@
+ECDSA_KEY_FILE_HOST=<full-path-to-.ecdsa.key.json>
+BLS_KEY_FILE_HOST=<full-path-to-.bls.key.json>
+OPERATOR_CONFIG_FILE_HOST=<full-path-to-operator_config.docker.yaml>

operator/docker/compose.yaml

@@ -0,0 +1,18 @@
+services:
+  operator:
+    env_file:
+      - .env
+    container_name: operator
+    image: operator:latest
+    build:
+      context: ../../
+      dockerfile: operator/docker/operator.Dockerfile
+
+    volumes:
+      - "${ECDSA_KEY_FILE_HOST}:/usr/src/config/operator.ecdsa.key.json:readonly"
+      - "${BLS_KEY_FILE_HOST}:/usr/src/config/operator.bls.key.json:readonly"
+      - "${OPERATOR_CONFIG_FILE_HOST}:/usr/src/config/operator.yaml:readonly"
+    restart: unless-stopped
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+

operator/docker/operator.Dockerfile

@@ -0,0 +1,45 @@
+FROM golang:1.22.4
+
+# Update default packages
+RUN apt-get update
+
+# Get Ubuntu packages
+RUN apt-get install -y \
+    build-essential \
+    curl \
+    openssl \
+    libssl-dev
+
+# Update new packages
+RUN apt-get update
+
+# Get Rust
+RUN curl https://sh.rustup.rs -sSf | bash -s -- -y
+
+# Add cargo to path
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+WORKDIR /usr/src/app
+
+# Copy the Makefile and the operator (for the FFI)
+COPY Makefile /usr/src/app
+COPY operator /usr/src/app/operator
+
+# Build the FFI
+RUN make build_all_ffi_linux
+
+# Copy dependencies
+COPY go.mod go.sum ./
+COPY metrics /usr/src/app/metrics
+COPY contracts/script/output /usr/src/app/contracts/script/output
+COPY contracts/bindings /usr/src/app/contracts/bindings
+COPY core /usr/src/app/core
+COPY common /usr/src/app/common
+
+# Download dependencies
+RUN go mod download && go mod tidy && go mod verify
+
+# Build the operator
+RUN go build -v -o /usr/local/bin/operator /usr/src/app/operator/cmd/main.go
+
+ENTRYPOINT [ "/usr/local/bin/operator", "start", "--config", "/usr/src/config/operator.yaml"]