feat: Operator methods missing, form Go SDK

CHANGELOG.md

@@ -34,6 +34,31 @@ Those changes in added, changed or breaking changes, should include usage exampl
         .unwrap();
   ```
 
+* Added functions `new()` and `validate()` to `Operator` struct in [#280](https://github.com/Layr-Labs/eigensdk-rs/pull/280).
+
+```rust
+    let operator = Operator::new( 
+      "f39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+      "70997970C51812dc3A010C7d01b50e0d17dc79C8",
+      "http://www.example.com/eigensdk-rs.json",
+      3
+    );
+  operator.validate();
+```
+
+* Added `OperatorMetadata` struct in [#280](https://github.com/Layr-Labs/eigensdk-rs/pull/280).
+
+```rust
+    let operator_metadata = OperatorMetadata {
+        name: "Ethereum Utopia".to_string(),
+        description: "Rust operator is good operator".to_string(),
+        logo: "https://goerli-operator-metadata.s3.amazonaws.com/eigenlayer.png".to_string(),
+        website: Some("https://test.com".to_string()),
+        twitter: Some("https://twitter.com/test".to_string()),
+    };
+    operator_metadata.validate();
+```
+
 * Added new method `update_avs_metadata_uri` in `avsregistry/writer` in [#344](https://github.com/Layr-Labs/eigensdk-rs/pull/344).
 
   ```rust

Cargo.toml

@@ -68,7 +68,7 @@ aws-config = "1.5.9"
 aws-sdk-kms = "1.49.0"
 backoff = { version = "0.4.0", features = ["futures", "tokio"] }
 clap = { version = "4.5.20", features = ["derive"] }
-eigen-common = {  version = "0.3.0", path = "crates/common/" }
+eigen-common = { version = "0.3.0", path = "crates/common/" }
 eigen-client-elcontracts = { version = "0.3.0", path = "crates/chainio/clients/elcontracts" }
 eigen-client-eth = { version = "0.3.0", path = "crates/chainio/clients/eth" }
 eigen-client-fireblocks = { version = "0.3.0", path = "crates/chainio/clients/fireblocks" }
@@ -127,7 +127,6 @@ uuid = { version = "1.11", features = ["v4"] }
 parking_lot = "0.12"
 
 
-
 # alloy
 alloy = { version = "0.9", features = [
     "sol-types",
@@ -136,4 +135,4 @@ alloy = { version = "0.9", features = [
     "signer-aws",
     "rlp",
     "json-rpc",
-] }
+] }

crates/chainio/clients/avsregistry/src/writer.rs

@@ -305,10 +305,8 @@ impl AvsRegistryChainWriter {
             })
             .collect();
 
-        let operator_id = FixedBytes::from(
-            operator_id_from_g1_pub_key(bls_key_pair.public_key())
-                .map_err(|_| AvsRegistryError::GetOperatorId)?,
-        );
+        let operator_id = operator_id_from_g1_pub_key(bls_key_pair.public_key())
+            .map_err(|_| AvsRegistryError::GetOperatorId)?;
 
         let churn_wallet = PrivateKeySigner::from_str(&churn_signer_private_key)
             .map_err(|_| AvsRegistryError::InvalidPrivateKey)?;

crates/chainio/clients/elcontracts/src/writer.rs

@@ -90,15 +90,15 @@ impl ELChainWriter {
     ///
     /// # Returns
     ///
-    /// * `FixedBytes<32>` - The transaction hash if successful, otherwise an error
+    /// * `TxHash` - The transaction hash if successful, otherwise an error
     ///
     /// # Errors
     ///
     /// * `ElContractsError` - if the call to the contract fails
     pub async fn register_as_operator(
         &self,
         operator: Operator,
-    ) -> Result<FixedBytes<32>, ElContractsError> {
+    ) -> Result<TxHash, ElContractsError> {
         info!("registering operator {:?} to EigenLayer", operator.address);
         let provider = get_signer(&self.signer.clone(), &self.provider);
 
@@ -109,7 +109,7 @@ impl ELChainWriter {
             let contract_call = contract_delegation_manager.registerAsOperator(
                 operator.address,
                 operator.allocation_delay,
-                operator.metadata_url.unwrap_or_default(),
+                operator.metadata_url,
             );
             contract_call.gas(300000)
         };
@@ -172,7 +172,7 @@ impl ELChainWriter {
         info!(tx_hash = %modify_operator_tx.tx_hash(), operator = %operator.address, "updated operator details tx");
 
         let contract_call_update_metadata_uri = contract_delegation_manager
-            .updateOperatorMetadataURI(operator.address, operator.metadata_url.unwrap_or_default());
+            .updateOperatorMetadataURI(operator.address, operator.metadata_url);
 
         let metadata_tx = contract_call_update_metadata_uri.send().await?;
 
@@ -897,9 +897,8 @@ mod tests {
 
         let operator = Operator {
             address: FIRST_ADDRESS, // can only register the address corresponding to the signer used in the writer
-            staker_opt_out_window_blocks: 3,
             delegation_approver_address: FIRST_ADDRESS,
-            metadata_url: Some("metadata_uri".to_string()),
+            metadata_url: "metadata_uri".to_string(),
             allocation_delay: 1,
         };
         el_chain_writer
@@ -929,9 +928,8 @@ mod tests {
 
         let operator = Operator {
             address,
-            staker_opt_out_window_blocks: 3,
             delegation_approver_address: Address::ZERO,
-            metadata_url: Some("eigensdk-rs".to_string()),
+            metadata_url: "eigensdk-rs".to_string(),
             allocation_delay: 1,
         };
 
@@ -946,9 +944,8 @@ mod tests {
 
         let operator_modified = Operator {
             address,
-            staker_opt_out_window_blocks: 3,
             delegation_approver_address: Address::ZERO,
-            metadata_url: Some("new-metadata".to_string()),
+            metadata_url: "new-metadata".to_string(),
             allocation_delay: 1,
         };
 

crates/crypto/bls/src/error.rs

@@ -2,8 +2,12 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum BlsError {
+    /// Invalid Bls Public Key
+    #[error("Invalid bls public key")]
+    InvalidPublicKey,
+
     /// Invalid Bls Private Key
-    #[error("Invalid bls private key   ")]
+    #[error("Invalid bls private key")]
     InvalidBlsPrivateKey,
 
     /// Invalid G1Affine

crates/services/avsregistry/src/chaincaller.rs

@@ -5,7 +5,8 @@ use async_trait::async_trait;
 use eigen_client_avsregistry::{error::AvsRegistryError, reader::AvsRegistryReader};
 use eigen_crypto_bls::{BlsG1Point, PublicKey};
 use eigen_services_operatorsinfo::operator_info::OperatorInfoService;
-use eigen_types::operator::{OperatorAvsState, OperatorInfo, OperatorPubKeys, QuorumAvsState};
+use eigen_types::avs_state::{OperatorAvsState, QuorumAvsState};
+use eigen_types::operator::{OperatorInfo, OperatorPubKeys};
 use eigen_utils::slashing::middleware::operatorstateretriever::OperatorStateRetriever::CheckSignaturesIndices;
 use std::collections::HashMap;
 
@@ -57,7 +58,7 @@ impl<R: AvsRegistryReader + Sync, S: OperatorInfoService + Sync> AvsRegistryServ
                 let avs_state = operators_avs_state
                     .entry(FixedBytes(*operator.operatorId))
                     .or_insert_with(|| OperatorAvsState {
-                        operator_id: *operator.operatorId,
+                        operator_id: operator.operatorId,
                         operator_info: OperatorInfo {
                             pub_keys: Some(info),
                         },
@@ -173,9 +174,8 @@ mod tests {
     use eigen_crypto_bls::BlsKeyPair;
     use eigen_services_operatorsinfo::fake_operator_info::FakeOperatorInfoService;
     use eigen_testing_utils::test_data::TestData;
-    use eigen_types::operator::{
-        OperatorAvsState, OperatorInfo, OperatorPubKeys, QuorumAvsState, QuorumNum,
-    };
+    use eigen_types::avs_state::{OperatorAvsState, QuorumAvsState};
+    use eigen_types::operator::{OperatorInfo, OperatorPubKeys, QuorumNum};
     use eigen_types::test::TestOperator;
     use serde::Deserialize;
 
@@ -287,7 +287,7 @@ mod tests {
             .unwrap();
 
         let expected_operator_avs_state = OperatorAvsState {
-            operator_id: test_operator.operator_id.into(),
+            operator_id: test_operator.operator_id,
             operator_info: OperatorInfo {
                 pub_keys: Some(OperatorPubKeys::from(test_operator.bls_keypair)),
             },

crates/services/avsregistry/src/fake_avs_registry_service.rs

@@ -6,8 +6,9 @@ use ark_ec::{short_weierstrass::Affine, AffineRepr, CurveGroup};
 use async_trait::async_trait;
 use eigen_client_avsregistry::error::AvsRegistryError;
 use eigen_crypto_bls::{BlsG1Point, OperatorId, PublicKey};
+use eigen_types::avs_state::{OperatorAvsState, QuorumAvsState};
 use eigen_types::{
-    operator::{OperatorAvsState, OperatorInfo, OperatorPubKeys, QuorumAvsState, QuorumNum},
+    operator::{OperatorInfo, OperatorPubKeys, QuorumNum},
     test::TestOperator,
 };
 use eigen_utils::slashing::middleware::operatorstateretriever::OperatorStateRetriever::CheckSignaturesIndices;
@@ -37,7 +38,7 @@ impl FakeAvsRegistryService {
         // populate the inner hashmap
         for op in test_operators {
             let state = OperatorAvsState {
-                operator_id: op.operator_id.into(),
+                operator_id: op.operator_id,
                 operator_info: OperatorInfo {
                     pub_keys: Some(OperatorPubKeys::from(op.bls_keypair)),
                 },

crates/services/avsregistry/src/lib.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 use alloy::primitives::FixedBytes;
 use async_trait::async_trait;
 use eigen_client_avsregistry::error::AvsRegistryError;
-use eigen_types::operator::{OperatorAvsState, QuorumAvsState};
+use eigen_types::avs_state::{OperatorAvsState, QuorumAvsState};
 use eigen_utils::slashing::middleware::operatorstateretriever::OperatorStateRetriever::CheckSignaturesIndices;
 
 pub mod chaincaller;

crates/services/bls_aggregation/src/bls_agg.rs

@@ -7,9 +7,10 @@ use eigen_crypto_bls::{BlsG1Point, BlsG2Point, Signature};
 use eigen_crypto_bn254::utils::verify_message;
 use eigen_logging::logger::SharedLogger;
 use eigen_services_avsregistry::AvsRegistryService;
+use eigen_types::avs_state::OperatorAvsState;
 use eigen_types::{
     avs::{SignatureVerificationError, SignedTaskResponseDigest, TaskIndex, TaskResponseDigest},
-    operator::{OperatorAvsState, QuorumThresholdPercentage, QuorumThresholdPercentages},
+    operator::{QuorumThresholdPercentage, QuorumThresholdPercentages},
 };
 use std::collections::HashMap;
 use tokio::{
@@ -649,7 +650,7 @@ impl<A: AvsRegistryService + Send + Sync + Clone + 'static> BlsAggregatorService
                                 signers_apk_g2,
                                 signers_agg_sig_g1,
                                 signers_operator_ids_set: HashMap::from([(
-                                    operator_state.operator_id.into(),
+                                    operator_state.operator_id,
                                     true,
                                 )]),
                                 signers_total_stake_per_quorum: operator_state.stake_per_quorum.clone(),

crates/services/bls_aggregation/src/bls_agg_test.rs

@@ -262,8 +262,7 @@ pub mod integration_test {
                 .to_string(),
         )
         .unwrap();
-        let operator_id =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair.public_key()).unwrap());
+        let operator_id = operator_id_from_g1_pub_key(bls_key_pair.public_key()).unwrap();
         let el_chain_reader = ELChainReader::new(
             get_test_logger(),
             None,
@@ -496,8 +495,7 @@ pub mod integration_test {
             .await
             .unwrap()
             ._0;
-        let operator_id =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair.public_key()).unwrap());
+        let operator_id = operator_id_from_g1_pub_key(bls_key_pair.public_key()).unwrap();
         assert_eq!(s, operator_id);
         handle
             .process_signature(TaskSignature::new(
@@ -652,10 +650,8 @@ pub mod integration_test {
         // Compute the signature and send it to the aggregation service
         let task_response = 123;
         let task_response_digest = hash(task_response);
-        let operator_id_1 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap());
-        let operator_id_2 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap());
+        let operator_id_1 = operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap();
+        let operator_id_2 = operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap();
         let bls_signature_1 = bls_key_pair_1.sign_message(task_response_digest.as_ref());
 
         handle
@@ -721,10 +717,8 @@ pub mod integration_test {
 
         let bls_key_pair_2 = BlsKeyPair::new(BLS_KEY_2.to_string()).unwrap();
 
-        let operator_id_1 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap());
-        let operator_id_2 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap());
+        let operator_id_1 = operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap();
+        let operator_id_2 = operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap();
         let el_chain_reader = ELChainReader::new(
             get_test_logger(),
             None,
@@ -894,10 +888,8 @@ pub mod integration_test {
         create_operator_set(http_endpoint.as_str(), avs_address).await;
         create_operator_set(http_endpoint.as_str(), avs_address).await;
 
-        let operator_id_1 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap());
-        let operator_id_2 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap());
+        let operator_id_1 = operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap();
+        let operator_id_2 = operator_id_from_g1_pub_key(bls_key_pair_2.public_key()).unwrap();
         let el_chain_reader = ELChainReader::new(
             get_test_logger(),
             None,
@@ -1059,8 +1051,7 @@ pub mod integration_test {
         let provider = get_provider(http_endpoint.as_str());
 
         let bls_key_pair_1 = BlsKeyPair::new(BLS_KEY_1.to_string()).unwrap();
-        let operator_id_1 =
-            FixedBytes::from(operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap());
+        let operator_id_1 = operator_id_from_g1_pub_key(bls_key_pair_1.public_key()).unwrap();
         // Create quorums
         let quorum_nums = Bytes::from([0u8, 1u8]);
         let quorum_threshold_percentages: QuorumThresholdPercentages = vec![100, 100];

crates/services/operatorsinfo/src/operatorsinfo_inmemory.rs

@@ -182,13 +182,7 @@ impl OperatorInfoServiceInMemory {
                                             if *entry_src == StateSource::Event
                                                 && state_src == StateSource::Historic => {}
                                         _ => {
-                                            id_map.insert(
-                                                addr,
-                                                (
-                                                    state_src.clone(),
-                                                    alloy::primitives::FixedBytes(operator_id),
-                                                ),
-                                            );
+                                            id_map.insert(addr, (state_src.clone(), operator_id));
                                         }
                                     }
                                 }
@@ -490,9 +484,7 @@ async fn query_past_registered_operator_events_and_fill_db(
     }
 
     for (i, address) in operator_address.iter().enumerate() {
-        let operator_id = FixedBytes(operator_id_from_g1_pub_key(
-            operator_pub_keys[i].g1_pub_key.clone(),
-        )?);
+        let operator_id = operator_id_from_g1_pub_key(operator_pub_keys[i].g1_pub_key.clone())?;
         if let Some(socket) = socket_map.get(&operator_id) {
             let message = OperatorsInfoMessage::InsertOperatorInfo(
                 Some(*address),
@@ -772,8 +764,7 @@ mod tests {
         let operator_details = Operator {
             address: signer.address(),
             delegation_approver_address: signer.address(),
-            staker_opt_out_window_blocks: 3,
-            metadata_url: Some("eigensdk-rs".to_string()),
+            metadata_url: "eigensdk-rs".to_string(),
             allocation_delay: 0,
         };