Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Elcontracts reader tests #130

Merged
merged 6 commits into from
Sep 24, 2024
Merged

Elcontracts reader tests #130

Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
f1a3017
Adding a test in elcontracts reader tests
pablodeymo Sep 16, 2024
d251b6b
tests added in elcontracts reader
pablodeymo Sep 16, 2024
60c100b
test_get_operator_details in elcontracts
pablodeymo Sep 16, 2024
06433af
Merge branch 'main' into elcontracts_reader_tests
pablodeymo Sep 20, 2024
1c83433
Update crates/chainio/clients/elcontracts/src/reader.rs
pablodeymo Sep 20, 2024
618a619
Update crates/chainio/clients/elcontracts/src/reader.rs
pablodeymo Sep 20, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
236 changes: 132 additions & 104 deletions crates/chainio/clients/elcontracts/src/reader.rs
View file
Open in desktop
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);
}
}
Loading