feat: add rewards-v2 related functionality

Makefile

@@ -52,7 +52,7 @@ MIDDLEWARE_CONTRACTS_ARGS:=$(patsubst %, --select '^%$$', $(shell echo $(MIDDLEW
 
 
 ### Core bindings ###
-CORE_CONTRACTS:="DelegationManager IRewardsCoordinator StrategyManager IEigenPod EigenPod IEigenPodManager EigenPodManager IStrategy AVSDirectory AllocationManager PermissionController"
+CORE_CONTRACTS:="DelegationManager IRewardsCoordinator RewardsCoordinator  StrategyManager IEigenPod EigenPod IEigenPodManager EigenPodManager IStrategy AVSDirectory AllocationManager PermissionController ERC20 Slasher ISlasher"
 CORE_CONTRACTS_LOCATION:=$(MIDDLEWARE_CONTRACTS_LOCATION)/lib/eigenlayer-contracts
 CORE_BINDINGS_PATH:=crates/utils/src/core
 # The echo is to remove quotes, and the patsubst to make the regex match the full text only

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

@@ -14,9 +14,9 @@ use eigen_types::operator::{
     bitmap_to_quorum_ids, bitmap_to_quorum_ids_from_u192, OperatorPubKeys,
 };
 use eigen_utils::{
-    deploy::stakeregistry::StakeRegistry, middleware::blsapkregistry::BLSApkRegistry,
+    middleware::blsapkregistry::BLSApkRegistry,
     middleware::operatorstateretriever::OperatorStateRetriever,
-    middleware::registrycoordinator::RegistryCoordinator,
+    middleware::registrycoordinator::RegistryCoordinator, middleware::stakeregistry::StakeRegistry,
 };
 
 use num_bigint::BigInt;

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

@@ -3,11 +3,11 @@ use alloy_primitives::{Address, FixedBytes, U256};
 use eigen_common::get_provider;
 use eigen_logging::logger::SharedLogger;
 use eigen_types::operator::Operator;
-use eigen_utils::middleware::{
+use eigen_utils::core::islasher::ISlasher;
+use eigen_utils::core::{
     avsdirectory::AVSDirectory, delegationmanager::DelegationManager, erc20::ERC20,
-    islasher::ISlasher, istrategy::IStrategy,
+    istrategy::IStrategy, rewardscoordinator::RewardsCoordinator,
 };
-
 #[derive(Debug, Clone)]
 pub struct ELChainReader {
     _logger: SharedLogger,
@@ -383,6 +383,65 @@ impl ELChainReader {
         let DelegationManager::isOperatorReturn { _0: is_operator_is } = is_operator;
         Ok(is_operator_is)
     }
+
+    /// Get Operator Avs Split
+    ///
+    /// # Arguments
+    ///
+    /// * `operator` - The operator's address
+    /// * `avs` - The Avs 's address
+    ///
+    /// # Returns
+    ///
+    /// * `u16` - the split for the specific operator for the specific avs
+    ///
+    /// # Errors
+    ///
+    /// * `ElContractsError` - if the call to the contract fails
+    pub async fn get_operator_avs_split(
+        &self,
+        operator: Address,
+        avs: Address,
+    ) -> Result<u16, ElContractsError> {
+        let provider = get_provider(&self.provider);
+
+        let contract_rewards_coordinator =
+            RewardsCoordinator::new(self.delegation_manager, provider);
+
+        Ok(contract_rewards_coordinator
+            .getOperatorAVSSplit(operator, avs)
+            .call()
+            .await
+            .map_err(ElContractsError::AlloyContractError)?
+            ._0)
+    }
+
+    /// Get Operator PI Split
+    ///
+    /// # Arguments
+    ///
+    /// * `operator` - The operator's address
+    ///
+    /// # Returns
+    ///
+    /// * `u16` - The split for a specific `operator` for Programmatic Incentives
+    ///
+    /// # Errors
+    ///
+    /// * `ElContractsError` - if the call to the contract fails
+    pub async fn get_operator_pi_split(&self, operator: Address) -> Result<u16, ElContractsError> {
+        let provider = get_provider(&self.provider);
+
+        let contract_rewards_coordinator =
+            RewardsCoordinator::new(self.delegation_manager, provider);
+
+        Ok(contract_rewards_coordinator
+            .getOperatorPISplit(operator)
+            .call()
+            .await
+            .map_err(ElContractsError::AlloyContractError)?
+            ._0)
+    }
 }
 
 #[cfg(test)]
@@ -399,13 +458,13 @@ mod tests {
         },
     };
     use eigen_utils::{
-        deploy::mockavsservicemanager::MockAvsServiceManager,
-        middleware::{
+        core::{
             avsdirectory::AVSDirectory::{self, calculateOperatorAVSRegistrationDigestHashReturn},
             delegationmanager::DelegationManager::{
                 self, calculateDelegationApprovalDigestHashReturn,
             },
         },
+        sdk::mockavsservicemanager::MockAvsServiceManager,
     };
     use std::str::FromStr;
 

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

@@ -3,8 +3,8 @@ use crate::reader::ELChainReader;
 use alloy_primitives::{Address, FixedBytes, TxHash, U256};
 use eigen_common::get_signer;
 pub use eigen_types::operator::Operator;
-use eigen_utils::deploy::irewardscoordinator::IRewardsCoordinator::{self, RewardsMerkleClaim};
-use eigen_utils::middleware::{
+use eigen_utils::core::irewardscoordinator::IRewardsCoordinator::{self, RewardsMerkleClaim};
+use eigen_utils::core::{
     delegationmanager::{
         DelegationManager::{self},
         IDelegationManager::OperatorDetails,
@@ -250,6 +250,78 @@ impl ELChainWriter {
         let tx = process_claim_call.send().await?;
         Ok(*tx.tx_hash())
     }
+
+    /// Set Operator Avs Split
+    /// Sets the split for a specific operator for a specific avs
+    /// Only callable by the operator
+    /// Split has to be between 0 and 10000 bips (inclusive)
+    /// The split will be activated after the activation delay
+    ///
+    /// # Arguments
+    ///
+    /// * `operator` - The operator who is setting the split
+    /// * `avs` - The avs for which the split is being set by the operator.
+    /// * `split` - The split for the operator for the specific avs in bips.
+    ///
+    /// # Returns
+    ///
+    /// * `Result<FixedBytes<32>, ElContractsError>` - The transaction hash if the claim is sent, otherwise an error.
+    ///
+    /// # Errors
+    ///
+    /// * `ElContractsError` - if the call to the contract fails.
+    pub async fn set_operator_avs_split(
+        &self,
+        operator: Address,
+        avs: Address,
+        split: u16,
+    ) -> Result<FixedBytes<32>, ElContractsError> {
+        let provider = get_signer(&self.signer, &self.provider);
+
+        let contract_rewards_coordinator =
+            IRewardsCoordinator::new(self.rewards_coordinator, &provider);
+
+        let set_operator_avs_split_call =
+            contract_rewards_coordinator.setOperatorAVSSplit(operator, avs, split);
+
+        let tx = set_operator_avs_split_call.send().await?;
+        Ok(*tx.tx_hash())
+    }
+
+    /// Set Operator PI Split
+    /// Sets the split for a specific operator for Programmatic Incentives.
+    /// Only callable by the operator
+    /// Split has to be between 0 and 10000 bips (inclusive)
+    /// The split will be activated after the activation delay
+    ///
+    /// # Arguments
+    ///
+    /// * `operator` - The operator on behalf of which the split is being set.
+    /// * `split` - The split for the operator for Programmatic Incentives in bips.
+    ///
+    /// # Returns
+    ///
+    /// * `Result<FixedBytes<32>, ElContractsError>` - The transaction hash if the claim is sent, otherwise an error.
+    ///
+    /// # Errors
+    ///
+    /// * `ElContractsError` - if the call to the contract fails.
+    pub async fn set_operator_pi_split(
+        &self,
+        operator: Address,
+        split: u16,
+    ) -> Result<FixedBytes<32>, ElContractsError> {
+        let provider = get_signer(&self.signer, &self.provider);
+
+        let contract_rewards_coordinator =
+            IRewardsCoordinator::new(self.rewards_coordinator, &provider);
+
+        let set_operator_pi_split_call =
+            contract_rewards_coordinator.setOperatorPISplit(operator, split);
+
+        let tx = set_operator_pi_split_call.send().await?;
+        Ok(*tx.tx_hash())
+    }
 }
 
 #[cfg(test)]
@@ -273,12 +345,14 @@ mod tests {
     };
     use eigen_types::operator::Operator;
     use eigen_utils::{
-        deploy::{
-            contractsregistry::ContractsRegistry::{self, get_test_valuesReturn},
+        core::{
+            delegationmanager::DelegationManager,
             irewardscoordinator::IRewardsCoordinator::{EarnerTreeMerkleLeaf, RewardsMerkleClaim},
+        },
+        sdk::{
+            contractsregistry::ContractsRegistry::{self, get_test_valuesReturn},
             mockavsservicemanager::MockAvsServiceManager,
         },
-        middleware::delegationmanager::DelegationManager,
     };
     use serial_test::serial;
     use std::str::FromStr;
@@ -521,4 +595,35 @@ mod tests {
         let receipt = wait_transaction(&http_endpoint, tx_hash).await.unwrap();
         assert!(receipt.status());
     }
+
+    #[tokio::test]
+    #[serial]
+    async fn test_set_operator_avs_split() {
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
+        let el_chain_writer = new_test_writer(http_endpoint.clone()).await;
+        let operator = address!("90f79bf6eb2c4f870365e785982e1f101e93b906"); // derived from  test private key in new_test_writer
+        let avs = get_service_manager_address(http_endpoint.clone()).await;
+        let split = 1000;
+        let tx_hash = el_chain_writer
+            .set_operator_avs_split(operator, avs, split)
+            .await
+            .unwrap();
+        let receipt = wait_transaction(&http_endpoint, tx_hash).await.unwrap();
+        assert!(receipt.status());
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn test_set_operator_pi_split() {
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
+        let el_chain_writer = new_test_writer(http_endpoint.clone()).await;
+        let operator = address!("90f79bf6eb2c4f870365e785982e1f101e93b906"); // derived from  test private key in new_test_writer
+        let split = 1000;
+        let tx_hash = el_chain_writer
+            .set_operator_pi_split(operator, split)
+            .await
+            .unwrap();
+        let receipt = wait_transaction(&http_endpoint, tx_hash).await.unwrap();
+        assert!(receipt.status());
+    }
 }

crates/contracts/foundry.toml

@@ -3,5 +3,5 @@ src = "src"
 out = "out"
 libs = ["lib"]
 fs_permissions = [{ access = "read-write", path = "./" }]
-
+via-ir = true
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

crates/contracts/script/DeployMockAvsRegistries.s.sol

@@ -9,8 +9,9 @@ import {IDelegationManager} from "eigenlayer-contracts/src/contracts/interfaces/
 import {IStrategyManager, IStrategy} from "eigenlayer-contracts/src/contracts/interfaces/IStrategyManager.sol";
 import {ISlasher} from "eigenlayer-contracts/src/contracts/interfaces/ISlasher.sol";
 import "eigenlayer-contracts/src/test/mocks/EmptyContract.sol";
-
+import {SocketRegistry} from "eigenlayer-middleware/src/SocketRegistry.sol";
 import "eigenlayer-middleware/src/RegistryCoordinator.sol" as blsregcoord;
+// import {ISocketRegistry} from "eigenlayer-middleware/src/interfaces/ISocketRegistry.sol";
 import {IServiceManager} from "eigenlayer-middleware/src/interfaces/IServiceManager.sol";
 import {IBLSApkRegistry, IIndexRegistry, IStakeRegistry} from "eigenlayer-middleware/src/RegistryCoordinator.sol";
 import {BLSApkRegistry} from "eigenlayer-middleware/src/BLSApkRegistry.sol";
@@ -153,12 +154,14 @@ contract DeployMockAvsRegistries is
                 address(stakeRegistryImplementation)
             );
         }
+        address socketRegistry  = address(new SocketRegistry(registryCoordinator));
 
         registryCoordinatorImplementation = new blsregcoord.RegistryCoordinator(
             blsregcoord.IServiceManager(address(mockAvsServiceManager)),
             blsregcoord.IStakeRegistry(address(stakeRegistry)),
             blsregcoord.IBLSApkRegistry(address(blsApkRegistry)),
-            blsregcoord.IIndexRegistry(address(indexRegistry))
+            blsregcoord.IIndexRegistry(address(indexRegistry)),
+            blsregcoord.ISocketRegistry(socketRegistry)
         );
 
         {

crates/contracts/src/MockAvsServiceManager.sol

@@ -17,14 +17,15 @@ contract MockAvsServiceManager is ServiceManagerBase, BLSSignatureChecker {
     )
         ServiceManagerBase(
             _avsDirectory,
+            _rewardsCoordinator,
             _registryCoordinator,
             _registryCoordinator.stakeRegistry()
         )
         BLSSignatureChecker(_registryCoordinator)
     {}
 
-    function initialize(address _initialOwner) external initializer {
+    function initialize(address _initialOwner,address _rewardsInitiator) external initializer {
         // TODO: setting _rewardsInitializer to be _initialOwner for now.
-        __ServiceManagerBase_init(_initialOwner);
+        __ServiceManagerBase_init(_initialOwner,_rewardsInitiator);
     }
 }

crates/eigen-cli/src/eigen_address.rs

@@ -4,7 +4,7 @@ use alloy::primitives::Address;
 use alloy::providers::Provider;
 use eigen_common::get_provider;
 use eigen_utils::{
-    middleware::delegationmanager::DelegationManager,
+    core::delegationmanager::DelegationManager,
     middleware::iblssignaturechecker::IBLSSignatureChecker,
     middleware::registrycoordinator::RegistryCoordinator,
 };

crates/utils/Cargo.toml

@@ -9,4 +9,4 @@ license-file.workspace = true
 
 [dependencies]
 alloy.workspace = true
-reqwest.workspace = true
+reqwest.workspace = true