feat: new method eject_operator in avsregistry/writer (#328)

### What Changed?
Add new method `eject_operator` to `avsregistry/writer`.

Related issue #310

### Reviewer Checklist

- [ ] New features are tested and documented
- [ ] PR updates the changelog with a description of changes
- [ ] PR has one of the `changelog-X` labels (if applies)
- [ ] Code deprecates any old functionality before removing it

Author: damiramirez

CHANGELOG.md

@@ -82,6 +82,18 @@ Those changes in added, changed or breaking changes, should include usage exampl
         .unwrap();
   ```
 
+* Added new method `eject_operator` in `avsregistry/writer` in [#328](https://github.com/Layr-Labs/eigensdk-rs/pull/328).
+
+  ```rust
+    let register_operator_address = address!("f39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
+    let quorum_nums = Bytes::from([0]);
+
+    let tx_hash = avs_writer
+        .eject_operator(register_operator_address, quorum_nums)
+        .await
+        .unwrap();
+  ```
+
 * Added new method `is_operator_set_quorum` in `avsregistry/writer` in [#296](https://github.com/Layr-Labs/eigensdk-rs/pull/296).
 
   ```rust

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

@@ -26,8 +26,10 @@ pub(crate) mod test_utils {
         sol_types::SolCall,
     };
     use eigen_common::get_signer;
+    use eigen_logging::get_test_logger;
     use eigen_testing_utils::anvil_constants::{
-        get_allocation_manager_address, get_erc20_mock_strategy, get_registry_coordinator_address,
+        get_allocation_manager_address, get_erc20_mock_strategy,
+        get_operator_state_retriever_address, get_registry_coordinator_address,
         get_service_manager_address, FIRST_PRIVATE_KEY,
     };
     use eigen_utils::slashing::{
@@ -39,6 +41,11 @@ pub(crate) mod test_utils {
         sdk::mockavsservicemanager::MockAvsServiceManager,
     };
 
+    use crate::reader::AvsRegistryChainReader;
+
+    pub(crate) const OPERATOR_BLS_KEY: &str =
+        "1371012690269088913462269866874713266643928125698382731338806296762673180359922";
+
     pub(crate) async fn create_operator_set(http_endpoint: &str, avs_address: Address) {
         let allocation_manager_addr =
             get_allocation_manager_address(http_endpoint.to_string()).await;
@@ -106,4 +113,22 @@ pub(crate) mod test_utils {
             .await
             .unwrap();
     }
+
+    pub(crate) async fn build_avs_registry_chain_reader(
+        http_endpoint: String,
+    ) -> AvsRegistryChainReader {
+        let registry_coordinator_addr =
+            get_registry_coordinator_address(http_endpoint.clone()).await;
+        let operator_state_retriever_address =
+            get_operator_state_retriever_address(http_endpoint.clone()).await;
+
+        AvsRegistryChainReader::new(
+            get_test_logger(),
+            registry_coordinator_addr,
+            operator_state_retriever_address,
+            http_endpoint.to_string(),
+        )
+        .await
+        .unwrap()
+    }
 }

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

@@ -375,6 +375,35 @@ impl AvsRegistryChainWriter {
         Ok(*tx.tx_hash())
     }
 
+    /// Force a deregistration of an operator from one or more quorums
+    ///
+    /// # Arguments
+    ///
+    /// * `operator_address` - The address of the operator to be ejected
+    /// * `quorum_numbers` - The quorum numbers to eject the operator from
+    ///
+    /// # Returns
+    ///
+    /// * `TxHash` - The transaction hash of the eject operator transaction
+    pub async fn eject_operator(
+        &self,
+        operator_address: Address,
+        quorum_numbers: Bytes,
+    ) -> Result<TxHash, AvsRegistryError> {
+        info!("ejecting operator from quorum with the AVS's registry coordinator");
+        let provider = get_signer(&self.signer.clone(), &self.provider);
+
+        let contract_registry_coordinator =
+            RegistryCoordinator::new(self.registry_coordinator_addr, provider);
+
+        contract_registry_coordinator.ejectOperator(operator_address, quorum_numbers)
+            .send()
+            .await
+            .map_err(AvsRegistryError::AlloyContractError)
+            .inspect(|tx| info!(tx_hash = ?tx, "successfully ejected operator from quorum with the AVS's registry coordinator"))
+            .map(|tx| *tx.tx_hash())
+    }
+
     /// This function is used to update the account identifier of the AVS's RegistryCoordinator.
     ///
     /// # Arguments
@@ -435,7 +464,9 @@ impl AvsRegistryChainWriter {
 mod tests {
 
     use super::AvsRegistryChainWriter;
+    use crate::test_utils::build_avs_registry_chain_reader;
     use crate::test_utils::create_operator_set;
+    use crate::test_utils::OPERATOR_BLS_KEY;
     use alloy::primitives::{Address, Bytes, FixedBytes, U256};
     use eigen_common::{get_provider, get_signer};
     use eigen_crypto_bls::BlsKeyPair;
@@ -773,4 +804,49 @@ mod tests {
             operator_set_params.kickBIPsOfTotalStake
         );
     }
+
+    #[tokio::test]
+    async fn test_eject_operator() {
+        let (_container, http_endpoint, _ws_endpoint) = start_m2_anvil_container().await;
+        let bls_key = OPERATOR_BLS_KEY.to_string();
+        let register_operator_address = FIRST_ADDRESS;
+        let private_key = FIRST_PRIVATE_KEY.to_string();
+        let quorum_nums = Bytes::from([0]);
+
+        let avs_writer =
+            build_avs_registry_chain_writer(http_endpoint.clone(), private_key.clone()).await;
+
+        test_register_operator(
+            &avs_writer,
+            bls_key,
+            quorum_nums.clone(),
+            http_endpoint.clone(),
+        )
+        .await;
+
+        let avs_reader = build_avs_registry_chain_reader(http_endpoint.clone()).await;
+        let is_registered = avs_reader
+            .is_operator_registered(register_operator_address)
+            .await
+            .unwrap();
+        assert!(is_registered);
+
+        let tx_hash = avs_writer
+            .eject_operator(register_operator_address, quorum_nums)
+            .await
+            .unwrap();
+
+        let tx_status = wait_transaction(&http_endpoint, tx_hash)
+            .await
+            .unwrap()
+            .status();
+
+        assert!(tx_status);
+
+        let is_registered = avs_reader
+            .is_operator_registered(register_operator_address)
+            .await
+            .unwrap();
+        assert!(!is_registered);
+    }
 }