Skip to content

Commit

Permalink
Elcontracts reader tests (#130)
Browse files Browse the repository at this point in the history 
Co-authored-by: Pablo Deymonnaz <[email protected]>
Co-authored-by: Pablo Deymonnaz <[email protected]>
  • Loading branch information
@TomasArrachea @pablodeymo
3 people authored Sep 24, 2024
1 parent f5bc4ef commit aeb6541
Showing 1 changed file with 132 additions and 104 deletions.
236 changes: 132 additions & 104 deletions crates/chainio/clients/elcontracts/src/reader.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,23 +44,21 @@ impl ELChainReader {

let contract_delegation_manager = DelegationManager::new(delegation_manager, provider);

let slasher_result = contract_delegation_manager.slasher().call().await;

match slasher_result {
Ok(slasher) => {
let DelegationManager::slasherReturn { _0: slasher_addr } = slasher;

Ok(Self {
_logger,
avs_directory,
slasher: slasher_addr,
delegation_manager,
provider: client.to_string(),
})
}

Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
let slasher = contract_delegation_manager
.slasher()
.call()
.await
.map_err(ElContractsError::AlloyContractError)?;

let DelegationManager::slasherReturn { _0: slasher_addr } = slasher;

Ok(Self {
_logger,
avs_directory,
slasher: slasher_addr,
delegation_manager,
provider: client.to_string(),
})
}

pub async fn calculate_delegation_approval_digest_hash(
Expand All @@ -73,7 +71,7 @@ impl ELChainReader {
) -> Result<FixedBytes<32>, ElContractsError> {
let provider = get_provider(&self.provider);
let contract_delegation_manager = DelegationManager::new(self.delegation_manager, provider);
let delegation_approval_digest_hash_result = contract_delegation_manager
let delegation_approval_digest_hash = contract_delegation_manager
.calculateDelegationApprovalDigestHash(
staker,
operator,
Expand All @@ -82,17 +80,13 @@ impl ELChainReader {
expiry,
)
.call()
.await;
match delegation_approval_digest_hash_result {
Ok(delegation_approval_digest_hash) => {
let DelegationManager::calculateDelegationApprovalDigestHashReturn {
_0: digest_hash,
} = delegation_approval_digest_hash;

Ok(digest_hash)
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
.await
.map_err(ElContractsError::AlloyContractError)?;

let DelegationManager::calculateDelegationApprovalDigestHashReturn { _0: digest_hash } =
delegation_approval_digest_hash;

Ok(digest_hash)
}

pub async fn calculate_operator_avs_registration_digest_hash(
Expand All @@ -106,20 +100,16 @@ impl ELChainReader {

let contract_avs_directory = AVSDirectory::new(self.avs_directory, provider);

let operator_avs_registration_digest_hash_result = contract_avs_directory
let operator_avs_registration_digest_hash = contract_avs_directory
.calculateOperatorAVSRegistrationDigestHash(operator, avs, salt, expiry)
.call()
.await;
.await
.map_err(ElContractsError::AlloyContractError)?;

match operator_avs_registration_digest_hash_result {
Ok(operator_avs_registration_digest_hash) => {
let AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn { _0: avs_hash } =
operator_avs_registration_digest_hash;
let AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn { _0: avs_hash } =
operator_avs_registration_digest_hash;

Ok(avs_hash)
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
Ok(avs_hash)
}

/// Get the operator's shares in a strategy
Expand Down Expand Up @@ -159,15 +149,14 @@ impl ELChainReader {

let contract_slasher = ISlasher::new(self.slasher, provider);

let operator_is_frozen_result = contract_slasher.isFrozen(operator_addr).call().await;
let operator_is_frozen = contract_slasher
.isFrozen(operator_addr)
.call()
.await
.map_err(ElContractsError::AlloyContractError)?;

match operator_is_frozen_result {
Ok(operator_is_frozen) => {
let ISlasher::isFrozenReturn { _0: is_froze } = operator_is_frozen;
Ok(is_froze)
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
let ISlasher::isFrozenReturn { _0: is_froze } = operator_is_frozen;
Ok(is_froze)
}

pub async fn service_manager_can_slash_operator_until_block(
Expand All @@ -179,20 +168,16 @@ impl ELChainReader {

let contract_slasher = ISlasher::new(self.slasher, provider);

let service_manager_can_slash_operator_until_block_result = contract_slasher
let service_manager_can_slash_operator_until_block = contract_slasher
.contractCanSlashOperatorUntilBlock(operator_addr, service_manager_addr)
.call()
.await;
.await
.map_err(ElContractsError::AlloyContractError)?;

match service_manager_can_slash_operator_until_block_result {
Ok(service_manager_can_slash_operator_until_block) => {
let ISlasher::contractCanSlashOperatorUntilBlockReturn { _0: can_slash } =
service_manager_can_slash_operator_until_block;
let ISlasher::contractCanSlashOperatorUntilBlockReturn { _0: can_slash } =
service_manager_can_slash_operator_until_block;

Ok(can_slash)
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
Ok(can_slash)
}

/// Get strategy and underlying ERC-20 token
Expand All @@ -218,24 +203,23 @@ impl ELChainReader {

let contract_strategy = IStrategy::new(strategy_addr, &provider);

let underlying_token_result = contract_strategy.underlyingToken().call().await;
match underlying_token_result {
Ok(underlying_token) => {
let IStrategy::underlyingTokenReturn {
_0: underlying_token_addr,
} = underlying_token;
let underlying_token = contract_strategy
.underlyingToken()
.call()
.await
.map_err(ElContractsError::AlloyContractError)?;

let contract_ierc20 = IERC20::new(underlying_token_addr, &provider);
let IStrategy::underlyingTokenReturn {
_0: underlying_token_addr,
} = underlying_token;

return Ok((
strategy_addr,
underlying_token_addr,
*contract_ierc20.address(),
));
}
let contract_ierc20 = IERC20::new(underlying_token_addr, &provider);

Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
Ok((
strategy_addr,
underlying_token_addr,
*contract_ierc20.address(),
))
}

pub async fn get_operator_details(
Expand All @@ -247,27 +231,23 @@ impl ELChainReader {
let contract_delegation_manager =
DelegationManager::new(self.delegation_manager, &provider);

let operator_det_result = contract_delegation_manager
let operator_det = contract_delegation_manager
.operatorDetails(operator)
.call()
.await;

match operator_det_result {
Ok(operator_det) => {
let DelegationManager::operatorDetailsReturn {
_0: operator_details,
} = operator_det;

Ok(Operator {
address: operator,
earnings_receiver_address: operator_details.earningsReceiver,
delegation_approver_address: operator_details.delegationApprover,
staker_opt_out_window_blocks: operator_details.stakerOptOutWindowBlocks,
metadata_url: None,
})
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
.await
.map_err(ElContractsError::AlloyContractError)?;

let DelegationManager::operatorDetailsReturn {
_0: operator_details,
} = operator_det;

Ok(Operator {
address: operator,
earnings_receiver_address: operator_details.earningsReceiver,
delegation_approver_address: operator_details.delegationApprover,
staker_opt_out_window_blocks: operator_details.stakerOptOutWindowBlocks,
metadata_url: None,
})
}

pub async fn is_operator_registered(
Expand All @@ -278,18 +258,14 @@ impl ELChainReader {

let contract_delegation_manager = DelegationManager::new(self.delegation_manager, provider);

let is_operator_result = contract_delegation_manager
let is_operator = contract_delegation_manager
.isOperator(operator)
.call()
.await;

match is_operator_result {
Ok(is_operator) => {
let DelegationManager::isOperatorReturn { _0: is_operator_is } = is_operator;
Ok(is_operator_is)
}
Err(e) => Err(ElContractsError::AlloyContractError(e)),
}
.await
.map_err(ElContractsError::AlloyContractError)?;

let DelegationManager::isOperatorReturn { _0: is_operator_is } = is_operator;
Ok(is_operator_is)
}
}

Expand All @@ -300,15 +276,20 @@ mod tests {
use alloy_primitives::{address, keccak256, Address, FixedBytes, U256};
use alloy_provider::Provider;
use eigen_logging::get_test_logger;
use eigen_testing_utils::anvil_constants::{self, ANVIL_HTTP_URL, ANVIL_RPC_URL};
use eigen_testing_utils::anvil_constants::{
self, get_erc20_mock_strategy, ANVIL_HTTP_URL, ANVIL_RPC_URL,
};
use eigen_utils::binding::{
mockAvsServiceManager, AVSDirectory,
AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn, DelegationManager,
DelegationManager::calculateDelegationApprovalDigestHashReturn,
};
use serial_test::serial;
use std::str::FromStr;
use tokio::time::{sleep, Duration};

const OPERATOR_ADDRESS: &str = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720";

async fn build_el_chain_reader() -> ELChainReader {
let delegation_manager_address = anvil_constants::get_delegation_manager_address().await;
let delegation_manager_contract = DelegationManager::new(
Expand Down Expand Up @@ -360,7 +341,7 @@ mod tests {
.await
.unwrap();

let Some(block) = block_info else { return };
let block = block_info.unwrap();
let timestamp = block.header.timestamp;
let expiry = U256::from::<u64>(timestamp + 100);
let calculate_digest_hash = el_chain_reader
Expand Down Expand Up @@ -412,7 +393,7 @@ mod tests {
.get_block_by_number(Number(current_block_number), true)
.await
.unwrap();
let Some(block) = block_info else { return };
let block = block_info.unwrap();

let timestamp = block.header.timestamp;
let expiry = U256::from::<u64>(timestamp + 100);
Expand All @@ -435,4 +416,51 @@ mod tests {

assert_eq!(hash, operator_hash);
}

#[tokio::test]
#[serial]
async fn check_strategy_shares_and_operator_frozen() {
let operator_addr = Address::from_str(OPERATOR_ADDRESS).unwrap();
let strategy_addr = get_erc20_mock_strategy().await;

let chain_reader = build_el_chain_reader().await;
let shares = chain_reader
.get_operator_shares_in_strategy(operator_addr, strategy_addr)
.await
.unwrap();

let zero = U256::ZERO;
assert!(shares > zero);

// test if operator is frozen
let frozen = chain_reader
.operator_is_frozen(operator_addr)
.await
.unwrap();
assert!(!frozen);

let service_manager_address = anvil_constants::get_service_manager_address().await;
let ret_can_slash = chain_reader
.service_manager_can_slash_operator_until_block(operator_addr, service_manager_address)
.await
.unwrap();

println!("ret_can_slash: {ret_can_slash}");
assert!(ret_can_slash == 0);
}

#[tokio::test]
#[serial]
async fn test_get_operator_details() {
let operator_addr = Address::from_str(OPERATOR_ADDRESS).unwrap();
let chain_reader = build_el_chain_reader().await;

let operator = chain_reader
.get_operator_details(operator_addr)
.await
.unwrap();

assert!(operator.metadata_url.is_none());
println!("{:?}", operator.metadata_url);
}
}

0 comments on commit aeb6541

Please sign in to comment.