From 29e17a6cf74f2df8972166a5f168702f13b36d30 Mon Sep 17 00:00:00 2001 From: "Supernovahs.eth" <91280922+supernovahs@users.noreply.github.com> Date: Thu, 18 Jul 2024 15:31:45 +0530 Subject: [PATCH] support alloy errors (#47) --- Cargo.lock | 78 +---- crates/chainio/clients/avsregistry/Cargo.toml | 1 + .../chainio/clients/avsregistry/src/error.rs | 16 + .../chainio/clients/avsregistry/src/reader.rs | 237 +++++++------ .../chainio/clients/avsregistry/src/writer.rs | 317 ++++++++++-------- crates/chainio/clients/elcontracts/Cargo.toml | 4 +- .../chainio/clients/elcontracts/src/error.rs | 4 + .../chainio/clients/elcontracts/src/reader.rs | 192 +++++++---- .../chainio/clients/elcontracts/src/writer.rs | 127 +++---- .../clients/fireblocks/src/get_transaction.rs | 8 + crates/crypto/keystore/Cargo.toml | 2 - crates/crypto/keystore/src/lib.rs | 3 +- 12 files changed, 543 insertions(+), 446 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1609e6a0..8d18f687 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1072,33 +1072,6 @@ dependencies = [ "thiserror", ] -[[package]] -name = "color-eyre" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55146f5e46f237f7423d74111267d4597b59b0dad0ffaf7303bce9945d843ad5" -dependencies = [ - "backtrace", - "color-spantrace", - "eyre", - "indenter", - "once_cell", - "owo-colors", - "tracing-error", -] - -[[package]] -name = "color-spantrace" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd6be1b2a7e382e2b98b43b2adcca6bb0e465af0bdd38123873ae61eb17a72c2" -dependencies = [ - "once_cell", - "owo-colors", - "tracing-core", - "tracing-error", -] - [[package]] name = "const-hex" version = "1.12.0" @@ -1386,6 +1359,7 @@ dependencies = [ name = "eigen-client-avsregistry" version = "0.0.1-alpha" dependencies = [ + "alloy-contract", "alloy-network", "alloy-primitives", "alloy-provider", @@ -1412,6 +1386,7 @@ dependencies = [ name = "eigen-client-elcontracts" version = "0.0.1-alpha" dependencies = [ + "alloy-contract", "alloy-eips", "alloy-primitives", "alloy-provider", @@ -1476,10 +1451,8 @@ name = "eigen-crypto-keystore" version = "0.0.1-alpha" dependencies = [ "aes", - "ark-bn254", "ark-ec", "ark-ff 0.4.2", - "color-eyre", "ctr", "eigen-crypto-bls", "eth-keystore", @@ -3219,12 +3192,6 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "owo-colors" -version = "3.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" - [[package]] name = "parity-scale-codec" version = "3.6.12" @@ -4360,15 +4327,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "sharded-slab" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" -dependencies = [ - "lazy_static", -] - [[package]] name = "signal-hook-registry" version = "1.4.2" @@ -4665,16 +4623,6 @@ dependencies = [ "syn 2.0.67", ] -[[package]] -name = "thread_local" -version = "1.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" -dependencies = [ - "cfg-if", - "once_cell", -] - [[package]] name = "threadpool" version = "1.8.1" @@ -4959,17 +4907,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" dependencies = [ "once_cell", - "valuable", -] - -[[package]] -name = "tracing-error" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e" -dependencies = [ - "tracing", - "tracing-subscriber", ] [[package]] @@ -4982,17 +4919,6 @@ dependencies = [ "tracing", ] -[[package]] -name = "tracing-subscriber" -version = "0.3.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" -dependencies = [ - "sharded-slab", - "thread_local", - "tracing-core", -] - [[package]] name = "try-lock" version = "0.2.5" diff --git a/crates/chainio/clients/avsregistry/Cargo.toml b/crates/chainio/clients/avsregistry/Cargo.toml index 85be276c..b9cd3282 100644 --- a/crates/chainio/clients/avsregistry/Cargo.toml +++ b/crates/chainio/clients/avsregistry/Cargo.toml @@ -27,6 +27,7 @@ tracing.workspace = true alloy-network.workspace = true alloy-signer.workspace = true alloy-signer-local.workspace = true +alloy-contract.workspace = true [lints] workspace = true diff --git a/crates/chainio/clients/avsregistry/src/error.rs b/crates/chainio/clients/avsregistry/src/error.rs index 0f337eaf..3010cd70 100644 --- a/crates/chainio/clients/avsregistry/src/error.rs +++ b/crates/chainio/clients/avsregistry/src/error.rs @@ -1,3 +1,5 @@ +use alloy_contract::Error as AlloyError; +use eigen_client_elcontracts::error::ElContractsError; use thiserror::Error; /// Error returned by AvsRegistry @@ -126,4 +128,18 @@ pub enum AvsRegistryError { /// Failed to subscribe to logs #[error("Could not subscribe to logs ")] SubscribeLogs, + + /// Alloy errors + #[error("Alloy contract error: {0}")] + AlloyContractError(#[from] AlloyError), + + /// ElContractsError compatibility + #[error("ElContractsError: {0}")] + ElContractsError(String), +} + +impl From for AvsRegistryError { + fn from(err: ElContractsError) -> Self { + AvsRegistryError::ElContractsError(err.to_string()) + } } diff --git a/crates/chainio/clients/avsregistry/src/reader.rs b/crates/chainio/clients/avsregistry/src/reader.rs index 8bdf1e21..17711ff7 100644 --- a/crates/chainio/clients/avsregistry/src/reader.rs +++ b/crates/chainio/clients/avsregistry/src/reader.rs @@ -33,7 +33,7 @@ impl AvsRegistryChainReader { registry_coordinator_addr: Address, operator_state_retriever_addr: Address, provider_url: String, - ) -> Result> { + ) -> Result { let provider = get_provider(&provider_url); let contract_registry_coordinator = @@ -65,16 +65,16 @@ impl AvsRegistryChainReader { provider: provider_url.clone(), }) } - Err(_) => Err(Box::new(AvsRegistryError::GetStakeRegistry)), + Err(_) => Err(AvsRegistryError::GetStakeRegistry), } } - Err(_) => Err(Box::new(AvsRegistryError::GetBlsApkRegistry)), + Err(_) => Err(AvsRegistryError::GetBlsApkRegistry), } } /// Get quorum count - pub async fn get_quorum_count(&self) -> Result> { + pub async fn get_quorum_count(&self) -> Result { let provider = get_provider(&self.provider); let contract_registry_coordinator = @@ -88,7 +88,7 @@ impl AvsRegistryChainReader { Ok(quorum) } - Err(_) => Err(Box::new(AvsRegistryError::GetQuorumCount)), + Err(_) => Err(AvsRegistryError::GetQuorumCount), } } @@ -97,7 +97,7 @@ impl AvsRegistryChainReader { &self, block_number: u32, quorum_numbers: Bytes, - ) -> Result>, Box> { + ) -> Result>, AvsRegistryError> { let provider = get_provider(&self.provider); let contract_operator_state_retriever = @@ -113,7 +113,7 @@ impl AvsRegistryChainReader { operator_state; Ok(quorum) } - Err(_) => Err(Box::new(AvsRegistryError::GetOperatorState)), + Err(_) => Err(AvsRegistryError::GetOperatorState), } } @@ -122,8 +122,7 @@ impl AvsRegistryChainReader { &self, block_number: u32, operator_id: B256, - ) -> Result<(U256, Vec>), Box> - { + ) -> Result<(U256, Vec>), AvsRegistryError> { let provider = get_provider(&self.provider); let contract_operator_state_retriever = @@ -142,9 +141,7 @@ impl AvsRegistryChainReader { } = operator_state_with_registry_coordinator_and_oeprator_id; Ok((stake, operator_state)) } - Err(_) => Err(Box::new( - AvsRegistryError::GetOperatorStateWithRegistryCoordinatorAndOperatorId, - )), + Err(_) => Err(AvsRegistryError::GetOperatorStateWithRegistryCoordinatorAndOperatorId), } } @@ -152,7 +149,7 @@ impl AvsRegistryChainReader { pub async fn get_operators_stake_in_quorums_at_current_block( &self, quorum_numbers: Bytes, - ) -> Result>, Box> { + ) -> Result>, AvsRegistryError> { let provider = get_provider(&self.provider); let current_block_number_result = provider.get_block_number().await; @@ -160,7 +157,7 @@ impl AvsRegistryChainReader { match current_block_number_result { Ok(current_block_number) => { if current_block_number > u32::MAX.into() { - return Err(Box::new(AvsRegistryError::BlockNumberOverflow)); + return Err(AvsRegistryError::BlockNumberOverflow); } let operators_stake_in_quorums_at_block_result = self @@ -174,12 +171,10 @@ impl AvsRegistryChainReader { Ok(operators_stake_in_quorums_at_block) => { Ok(operators_stake_in_quorums_at_block) } - Err(_) => Err(Box::new( - AvsRegistryError::GetOperatorStakeInQuorumAtBlockNumber, - )), + Err(_) => Err(AvsRegistryError::GetOperatorStakeInQuorumAtBlockNumber), } } - Err(_) => Err(Box::new(AvsRegistryError::GetBlockNumber)), + Err(_) => Err(AvsRegistryError::GetBlockNumber), } } @@ -188,8 +183,7 @@ impl AvsRegistryChainReader { &self, operator_id: B256, block_number: u32, - ) -> Result<(Vec, Vec>), Box> - { + ) -> Result<(Vec, Vec>), AvsRegistryError> { let result_ = self .get_operators_stake_in_quorums_at_block_operator_id(block_number, operator_id) .await; @@ -201,9 +195,7 @@ impl AvsRegistryChainReader { let s = (quorums, operator_stakes); Ok(s) } - Err(_) => Err(Box::new( - AvsRegistryError::GetOperatorStakeInQuorumAtBlockOperatorId, - )), + Err(_) => Err(AvsRegistryError::GetOperatorStakeInQuorumAtBlockOperatorId), } } @@ -211,30 +203,42 @@ impl AvsRegistryChainReader { pub async fn get_operators_stake_in_quorums_of_operator_at_current_block( &self, operator_id: B256, - ) -> Result<(Vec, Vec>), Box> - { + ) -> Result<(Vec, Vec>), AvsRegistryError> { let provider = get_provider(&self.provider); - let current_block_number = provider.get_block_number().await?; + let current_block_number_result = provider.get_block_number().await; - if current_block_number > u32::MAX.into() { - return Err(Box::new(AvsRegistryError::BlockNumberOverflow)); - } + match current_block_number_result { + Ok(current_block_number) => { + if current_block_number > u32::MAX.into() { + return Err(AvsRegistryError::BlockNumberOverflow); + } - let operator_stake_in_quorum_of_operaotr_at_block = self - .get_operators_stake_in_quorums_of_operator_at_block( - operator_id, - current_block_number as u32, - ) - .await?; - Ok(operator_stake_in_quorum_of_operaotr_at_block) + let operator_stake_in_quorum_of_operaotr_at_block_result = self + .get_operators_stake_in_quorums_of_operator_at_block( + operator_id, + current_block_number as u32, + ) + .await; + + match operator_stake_in_quorum_of_operaotr_at_block_result { + Ok(operator_stake_in_quorum_of_operaotr_at_block) => { + Ok(operator_stake_in_quorum_of_operaotr_at_block) + } + Err(e) => Err(e), + } + } + Err(e) => Err(AvsRegistryError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )), + } } /// Get operator stake in quorums of operator at current block pub async fn get_operator_stake_in_quorums_of_operator_at_current_block( &self, operator_id: B256, - ) -> Result, Box> { + ) -> Result, AvsRegistryError> { let provider = get_provider(&self.provider); let registry_coordinator = @@ -270,7 +274,7 @@ impl AvsRegistryChainReader { reference_block_number: u32, quorum_numbers: Vec, non_signer_operator_ids: Vec>, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_operator_state_retriever = @@ -294,7 +298,7 @@ impl AvsRegistryChainReader { pub async fn get_operator_id( &self, operator_address: Address, - ) -> Result, Box> { + ) -> Result, AvsRegistryError> { let provider = get_provider(&self.provider); let contract_registry_coordinator = @@ -312,7 +316,7 @@ impl AvsRegistryChainReader { pub async fn get_operator_from_id( &self, operator_id: [u8; 32], - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_registry_coordinator = @@ -333,7 +337,7 @@ impl AvsRegistryChainReader { pub async fn is_operator_registered( &self, operator_address: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_registry_coordinator = @@ -351,57 +355,76 @@ impl AvsRegistryChainReader { Ok(operator_status == 1) } + /// Queies existing operators from for a particular block range /// Queies existing operators from for a particular block range pub async fn query_existing_registered_operator_pub_keys( &self, start_block: u64, mut stop_block: u64, - ) -> Result<(Vec
, Vec), Box> { + ) -> Result<(Vec
, Vec), AvsRegistryError> { let provider = get_provider(&self.provider); let query_block_range = 1024; - let current_block_number = provider.get_block_number().await?; - if stop_block.is_zero() { - stop_block = current_block_number; - } - let mut i = start_block; - let mut operator_addresses: Vec
= vec![]; - let mut operator_pub_keys: Vec = vec![]; - while i <= stop_block { - let mut to_block = i + (query_block_range - 1); - if to_block > stop_block { - to_block = stop_block; - } - let filter = Filter::new() - .select(i..to_block) - .event("NewPubkeyRegistration(address,(uint256,uint256),(uint256[2],uint256[2]))") - .address(self.bls_apk_registry_addr); - - let logs = provider.get_logs(&filter).await?; - debug!(transactionLogs = ?logs, "avsRegistryChainReader.QueryExistingRegisteredOperatorPubKeys"); - - for v_log in logs.iter() { - let pub_key_reg_option = v_log - .log_decode::() - .ok(); - if let Some(pub_key_reg) = pub_key_reg_option { - let data = pub_key_reg.data(); - let operator_addr = data.operator; - operator_addresses.push(operator_addr); - let g1_pub_key = data.pubkeyG1.clone(); - let g2_pub_key = data.pubkeyG2.clone(); - - let operator_pub_key = OperatorPubKeys { - g1_pub_key, - g2_pub_key, - }; - - operator_pub_keys.push(operator_pub_key); + let current_block_number_result = provider.get_block_number().await; + + match current_block_number_result { + Ok(current_block_number) => { + if stop_block.is_zero() { + stop_block = current_block_number; + } + let mut i = start_block; + let mut operator_addresses: Vec
= vec![]; + let mut operator_pub_keys: Vec = vec![]; + while i <= stop_block { + let mut to_block = i + (query_block_range - 1); + if to_block > stop_block { + to_block = stop_block; + } + let filter = Filter::new() + .select(i..to_block) + .event("NewPubkeyRegistration(address,(uint256,uint256),(uint256[2],uint256[2]))") + .address(self.bls_apk_registry_addr); + + let logs_result = provider.get_logs(&filter).await; + + match logs_result { + Ok(logs) => { + debug!(transactionLogs = ?logs, "avsRegistryChainReader.QueryExistingRegisteredOperatorPubKeys"); + + for v_log in logs.iter() { + if let Ok(pub_key_reg) = + v_log.log_decode::() + { + let data = pub_key_reg.data(); + let operator_addr = data.operator; + operator_addresses.push(operator_addr); + let g1_pub_key = data.pubkeyG1.clone(); + let g2_pub_key = data.pubkeyG2.clone(); + + let operator_pub_key = OperatorPubKeys { + g1_pub_key, + g2_pub_key, + }; + + operator_pub_keys.push(operator_pub_key); + } + } + } + Err(e) => { + return Err(AvsRegistryError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )) + } + } + i += query_block_range; } + + Ok((operator_addresses, operator_pub_keys)) } - i += 1024; + Err(e) => Err(AvsRegistryError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )), } - Ok((operator_addresses, operator_pub_keys)) } /// Query existing operator sockets @@ -409,7 +432,7 @@ impl AvsRegistryChainReader { &self, start_block: u64, stop_block: u64, - ) -> Result, String>, Box> { + ) -> Result, String>, AvsRegistryError> { let provider = get_provider(&self.provider); let mut operator_id_to_socket = HashMap::new(); @@ -429,28 +452,46 @@ impl AvsRegistryChainReader { .event("OperatorSocketUpdate(bytes32,string)") .address(self.registry_coordinator_addr); if stop_block == 0 { - let current_block_number = provider.get_block_number().await?; + let current_block_number_result = provider.get_block_number().await; + + match current_block_number_result { + Ok(current_block_number) => { + filter = filter.clone().select(start_block..current_block_number); + } - filter = filter.clone().select(start_block..current_block_number); + Err(e) => { + return Err(AvsRegistryError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )) + } + } }; - let logs = provider.get_logs(&filter).await?; - - for v_log in logs.iter() { - let socket_update_filter_option = v_log - .log_decode::() - .ok(); - if let Some(socket_update_filter) = socket_update_filter_option { - let data = socket_update_filter.data(); - let operator_id = data.operatorId; - let socket = &data.socket; - operator_id_to_socket.insert(operator_id, socket.clone()); + let logs_result = provider.get_logs(&filter).await; + + match logs_result { + Ok(logs) => { + for v_log in logs.iter() { + let socket_update_filter_option = v_log + .log_decode::() + .ok(); + if let Some(socket_update_filter) = socket_update_filter_option { + let data = socket_update_filter.data(); + let operator_id = data.operatorId; + let socket = &data.socket; + operator_id_to_socket.insert(operator_id, socket.clone()); + } + } + + i += query_block_range; + } + Err(e) => { + return Err(AvsRegistryError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )) } } - - i += query_block_range; } - Ok(operator_id_to_socket) } } diff --git a/crates/chainio/clients/avsregistry/src/writer.rs b/crates/chainio/clients/avsregistry/src/writer.rs index a5170ebf..5a126538 100644 --- a/crates/chainio/clients/avsregistry/src/writer.rs +++ b/crates/chainio/clients/avsregistry/src/writer.rs @@ -20,6 +20,7 @@ use eigen_crypto_bls::attestation::KeyPair; use tracing::info; use RegistryCoordinator::SignatureWithSaltAndExpiry; +use crate::error::AvsRegistryError; use eigen_utils::{ binding::{ServiceManagerBase, StakeRegistry}, get_provider, get_signer, @@ -45,55 +46,73 @@ impl AvsRegistryChainWriter { signer: String, registry_coordinator_addr: Address, operator_state_retriever_addr: Address, - ) -> Result> { + ) -> Result { let fill_provider = get_provider(&provider); let contract_registry_coordinator = RegistryCoordinator::new(registry_coordinator_addr, &fill_provider); - let service_manager_addr = contract_registry_coordinator - .serviceManager() - .call() - .await?; - let RegistryCoordinator::serviceManagerReturn { - _0: service_manager, - } = service_manager_addr; - let contract_service_manager_base = - ServiceManagerBase::new(service_manager, &fill_provider); - - let bls_apk_registry_addr = contract_registry_coordinator - .blsApkRegistry() - .call() - .await?; - let RegistryCoordinator::blsApkRegistryReturn { - _0: bls_apk_registry, - } = bls_apk_registry_addr; - let stake_registry_addr = contract_registry_coordinator.stakeRegistry().call().await?; - let RegistryCoordinator::stakeRegistryReturn { _0: stake_registry } = stake_registry_addr; - let contract_stake_registry = StakeRegistry::new(stake_registry, &fill_provider); - - let delegation_manager_return = contract_stake_registry.delegation().call().await?; - - let StakeRegistry::delegationReturn { - _0: delegation_manager_addr, - } = delegation_manager_return; - let avs_directory_addr = contract_service_manager_base.avsDirectory().call().await?; - - let ServiceManagerBase::avsDirectoryReturn { _0: avs_directory } = avs_directory_addr; - - let el_reader = - ELChainReader::build(delegation_manager_addr, avs_directory, &provider).await?; - - Ok(AvsRegistryChainWriter { - service_manager_addr: service_manager, - registry_coordinator_addr, - operator_state_retriever_addr, - stake_registry_addr: stake_registry, - bls_apk_registry_addr: bls_apk_registry, - el_reader, - provider: provider.clone(), - signer: signer.clone(), - }) + let service_manager_addr_result = + contract_registry_coordinator.serviceManager().call().await; + + match service_manager_addr_result { + Ok(service_manager_addr) => { + let RegistryCoordinator::serviceManagerReturn { + _0: service_manager, + } = service_manager_addr; + let contract_service_manager_base = + ServiceManagerBase::new(service_manager, &fill_provider); + + let bls_apk_registry_addr_result = + contract_registry_coordinator.blsApkRegistry().call().await; + + match bls_apk_registry_addr_result { + Ok(bls_apk_registry_addr) => { + let RegistryCoordinator::blsApkRegistryReturn { + _0: bls_apk_registry, + } = bls_apk_registry_addr; + let stake_registry_addr = + contract_registry_coordinator.stakeRegistry().call().await?; + let RegistryCoordinator::stakeRegistryReturn { _0: stake_registry } = + stake_registry_addr; + let contract_stake_registry = + StakeRegistry::new(stake_registry, &fill_provider); + + let delegation_manager_return = + contract_stake_registry.delegation().call().await?; + + let StakeRegistry::delegationReturn { + _0: delegation_manager_addr, + } = delegation_manager_return; + let avs_directory_addr = + contract_service_manager_base.avsDirectory().call().await?; + + let ServiceManagerBase::avsDirectoryReturn { _0: avs_directory } = + avs_directory_addr; + + let el_reader_result = + ELChainReader::build(delegation_manager_addr, avs_directory, &provider) + .await; + + match el_reader_result { + Ok(el_reader) => Ok(AvsRegistryChainWriter { + service_manager_addr: service_manager, + registry_coordinator_addr, + operator_state_retriever_addr, + stake_registry_addr: stake_registry, + bls_apk_registry_addr: bls_apk_registry, + el_reader, + provider: provider.clone(), + signer: signer.clone(), + }), + Err(e) => Err(AvsRegistryError::ElContractsError(e.to_string())), + } + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } } /// Register operator in quorum with avs registry coordinator @@ -104,7 +123,7 @@ impl AvsRegistryChainWriter { operator_to_avs_registration_sig_expiry: U256, quorum_numbers: Bytes, socket: String, - ) -> Result> { + ) -> Result { let provider = get_signer(self.signer.clone(), &self.provider); let wallet = PrivateKeySigner::from_str(&self.signer).expect("failed to generate wallet "); @@ -112,84 +131,99 @@ impl AvsRegistryChainWriter { info!(avs_service_manager = %self.service_manager_addr, operator= %wallet.address(),quorum_numbers = ?quorum_numbers,"quorum_numbers,registering operator with the AVS's registry coordinator"); let contract_registry_coordinator = RegistryCoordinator::new(self.registry_coordinator_addr, provider); - let g1_hashes_msg_to_sign_return = contract_registry_coordinator + let g1_hashes_msg_to_sign_return_result = contract_registry_coordinator .pubkeyRegistrationMessageHash(wallet.address()) .call() - .await?; - let RegistryCoordinator::pubkeyRegistrationMessageHashReturn { - _0: g1_hashes_msg_to_sign, - } = g1_hashes_msg_to_sign_return; - let signed_msg = convert_to_bn254_g1_point( - bls_key_pair - .sign_hashes_to_curve_message(G1Projective::from( - convert_bn254_to_ark(G1Point { - X: g1_hashes_msg_to_sign.X, - Y: g1_hashes_msg_to_sign.Y, - }) - .point, - )) - .sig(), - ); - - let g1_pubkey_bn254 = convert_to_bn254_g1_point(bls_key_pair.get_pub_key_g1()); - let g2_projective = bls_key_pair - .get_pub_key_g2() - .expect("Failed to get g2 projective"); - - let g2_pubkey_bn254 = convert_to_bn254_g2_point(g2_projective); - - let pub_key_reg_params = PubkeyRegistrationParams { - pubkeyRegistrationSignature: signed_msg, - pubkeyG1: g1_pubkey_bn254, - pubkeyG2: g2_pubkey_bn254, - }; - - let msg_to_sign = self - .el_reader - .calculate_operator_avs_registration_digest_hash( - wallet.address(), - self.service_manager_addr, - operator_to_avs_registration_sig_salt, - operator_to_avs_registration_sig_expiry, - ) - .await?; - - let operator_signature = wallet - .sign_message_sync(msg_to_sign.as_slice()) - .expect("failed to sign message"); - - let operator_signature_with_salt_and_expiry = SignatureWithSaltAndExpiry { - signature: operator_signature.as_bytes().into(), - salt: operator_to_avs_registration_sig_salt, - expiry: operator_to_avs_registration_sig_expiry, - }; - - let contract_call = contract_registry_coordinator.registerOperator( - quorum_numbers.clone(), - socket, - RegistryPubkeyRegistrationParams { - pubkeyRegistrationSignature: RegistryG1Point { - X: pub_key_reg_params.pubkeyRegistrationSignature.X, - Y: pub_key_reg_params.pubkeyRegistrationSignature.Y, - }, - pubkeyG1: RegistryG1Point { - X: pub_key_reg_params.pubkeyG1.X, - Y: pub_key_reg_params.pubkeyG1.Y, - }, - pubkeyG2: RegistryG2Point { - X: pub_key_reg_params.pubkeyG2.X, - Y: pub_key_reg_params.pubkeyG2.Y, - }, - }, - operator_signature_with_salt_and_expiry, - ); - - let tx_call = contract_call.gas(2000000); - let tx = tx_call.send().await?; - - // tracing info - info!(tx_hash = %tx.tx_hash(), avs_service_manager = %self.service_manager_addr,operator = %wallet.address(),quorum_numbers = ?quorum_numbers , "successfully registered operator with AVS registry coordinator"); - Ok(*tx.tx_hash()) + .await; + + match g1_hashes_msg_to_sign_return_result { + Ok(g1_hashes_msg_to_sign_return) => { + let RegistryCoordinator::pubkeyRegistrationMessageHashReturn { + _0: g1_hashes_msg_to_sign, + } = g1_hashes_msg_to_sign_return; + let signed_msg = convert_to_bn254_g1_point( + bls_key_pair + .sign_hashes_to_curve_message(G1Projective::from( + convert_bn254_to_ark(G1Point { + X: g1_hashes_msg_to_sign.X, + Y: g1_hashes_msg_to_sign.Y, + }) + .point, + )) + .sig(), + ); + + let g1_pubkey_bn254 = convert_to_bn254_g1_point(bls_key_pair.get_pub_key_g1()); + let g2_projective = bls_key_pair + .get_pub_key_g2() + .expect("Failed to get g2 projective"); + + let g2_pubkey_bn254 = convert_to_bn254_g2_point(g2_projective); + + let pub_key_reg_params = PubkeyRegistrationParams { + pubkeyRegistrationSignature: signed_msg, + pubkeyG1: g1_pubkey_bn254, + pubkeyG2: g2_pubkey_bn254, + }; + + let msg_to_sign_result = self + .el_reader + .calculate_operator_avs_registration_digest_hash( + wallet.address(), + self.service_manager_addr, + operator_to_avs_registration_sig_salt, + operator_to_avs_registration_sig_expiry, + ) + .await; + + match msg_to_sign_result { + Ok(msg_to_sign) => { + let operator_signature = wallet + .sign_message_sync(msg_to_sign.as_slice()) + .expect("failed to sign message"); + + let operator_signature_with_salt_and_expiry = SignatureWithSaltAndExpiry { + signature: operator_signature.as_bytes().into(), + salt: operator_to_avs_registration_sig_salt, + expiry: operator_to_avs_registration_sig_expiry, + }; + + let contract_call = contract_registry_coordinator.registerOperator( + quorum_numbers.clone(), + socket, + RegistryPubkeyRegistrationParams { + pubkeyRegistrationSignature: RegistryG1Point { + X: pub_key_reg_params.pubkeyRegistrationSignature.X, + Y: pub_key_reg_params.pubkeyRegistrationSignature.Y, + }, + pubkeyG1: RegistryG1Point { + X: pub_key_reg_params.pubkeyG1.X, + Y: pub_key_reg_params.pubkeyG1.Y, + }, + pubkeyG2: RegistryG2Point { + X: pub_key_reg_params.pubkeyG2.X, + Y: pub_key_reg_params.pubkeyG2.Y, + }, + }, + operator_signature_with_salt_and_expiry, + ); + + let tx_call = contract_call.gas(2000000); + let tx_result = tx_call.send().await; + + match tx_result { + Ok(tx) => { + info!(tx_hash = ?tx,"succesfully deregistered operator with the AVS's registry coordinator" ); + return Ok(*tx.tx_hash()); + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } + } + Err(e) => Err(AvsRegistryError::ElContractsError(e.to_string())), + } + } + Err(_) => Err(AvsRegistryError::PubKeyRegistrationMessageHash), + } } /// Update stakes of entire operator set for quorums @@ -197,7 +231,7 @@ impl AvsRegistryChainWriter { &self, operators_per_quorum: Vec>, quorum_number: Bytes, - ) -> Result> { + ) -> Result { info!(quorum_numbers = %quorum_number, "updating stakes for entire operator set"); let provider = get_signer(self.signer.clone(), &self.provider); let contract_registry_coordinator = @@ -206,18 +240,22 @@ impl AvsRegistryChainWriter { let contract_call = contract_registry_coordinator .updateOperatorsForQuorum(operators_per_quorum, quorum_number.clone()); - let tx = contract_call.send().await?; + let tx_result = contract_call.send().await; - // tracing info - info!(tx_hash = ?tx, quorum_numbers = %quorum_number,"succesfully updated stakes for entire operator set" ); - return Ok(*tx.tx_hash()); + match tx_result { + Ok(tx) => { + info!(tx_hash = ?tx, quorum_numbers = %quorum_number," update stakes for entire operator set tx" ); + return Ok(*tx.tx_hash()); + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } } /// Update stakes of operator subset for all quorums pub async fn update_stakes_of_operator_subset_for_all_quorums( &self, operators: Vec
, - ) -> Result> { + ) -> Result { info!(operators = ?operators, "updating stakes of operator subset for all quorums"); let provider = get_signer(self.signer.clone(), &self.provider); @@ -227,17 +265,22 @@ impl AvsRegistryChainWriter { let contract_call = contract_registry_coordinator.updateOperators(operators); - let tx = contract_call.send().await?; + let tx_result = contract_call.send().await; - info!(tx_hash = ?tx,"ssuccesfully updated stakes of operator subset for all quorums" ); - Ok(*tx.tx_hash()) + match tx_result { + Ok(tx) => { + info!(tx_hash = ?tx,"succesfully updated stakes of operator subset for all quorums" ); + Ok(*tx.tx_hash()) + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } } /// Deregister operator pub async fn deregister_operator( &self, quorum_numbers: Bytes, - ) -> Result> { + ) -> Result { info!("deregistering operator with the AVS's registry coordinator"); let provider = get_signer(self.signer.clone(), &self.provider); @@ -246,9 +289,13 @@ impl AvsRegistryChainWriter { let contract_call = contract_registry_coordinator.deregisterOperator(quorum_numbers); - let tx = contract_call.send().await?; - - info!(tx_hash = ?tx,"succesfully deregistered operator with the AVS's registry coordinator" ); - return Ok(*tx.tx_hash()); + let tx_result = contract_call.send().await; + match tx_result { + Ok(tx) => { + info!(tx_hash = ?tx,"succesfully deregistered operator with the AVS's registry coordinator" ); + Ok(*tx.tx_hash()) + } + Err(e) => Err(AvsRegistryError::AlloyContractError(e)), + } } } diff --git a/crates/chainio/clients/elcontracts/Cargo.toml b/crates/chainio/clients/elcontracts/Cargo.toml index 71b103ed..c489eaec 100644 --- a/crates/chainio/clients/elcontracts/Cargo.toml +++ b/crates/chainio/clients/elcontracts/Cargo.toml @@ -12,7 +12,7 @@ license-file.workspace = true eigen-types.workspace=true thiserror.workspace = true tracing.workspace = true - +alloy-contract.workspace = true eigen-utils.workspace = true alloy-primitives.workspace = true @@ -23,4 +23,4 @@ eigen-utils.workspace = true alloy-signer-local.workspace = true alloy-provider.workspace = true tokio.workspace = true -alloy-eips.workspace = true +alloy-eips.workspace = true \ No newline at end of file diff --git a/crates/chainio/clients/elcontracts/src/error.rs b/crates/chainio/clients/elcontracts/src/error.rs index 5290775e..a73b1b6b 100644 --- a/crates/chainio/clients/elcontracts/src/error.rs +++ b/crates/chainio/clients/elcontracts/src/error.rs @@ -1,3 +1,4 @@ +use alloy_contract::Error as AlloyError; use thiserror::Error; #[derive(Debug, Error)] @@ -65,4 +66,7 @@ pub enum ElContractsError { /// update metadata uri #[error("Failed to update metadata uri")] UpdateMetadataUri, + + #[error("Alloy contract error: {0}")] + AlloyContractError(#[from] AlloyError), } diff --git a/crates/chainio/clients/elcontracts/src/reader.rs b/crates/chainio/clients/elcontracts/src/reader.rs index 6933494a..61175de0 100644 --- a/crates/chainio/clients/elcontracts/src/reader.rs +++ b/crates/chainio/clients/elcontracts/src/reader.rs @@ -1,3 +1,4 @@ +use crate::error::ElContractsError; use alloy_primitives::{Address, FixedBytes, U256}; use eigen_types::operator::Operator; use eigen_utils::{ @@ -32,21 +33,27 @@ impl ELChainReader { delegation_manager: Address, avs_directory: Address, client: &String, - ) -> Result> { + ) -> Result { let provider = get_provider(client); let contract_delegation_manager = DelegationManager::new(delegation_manager, provider); - let slasher = contract_delegation_manager.slasher().call().await?; + let slasher_result = contract_delegation_manager.slasher().call().await; - let DelegationManager::slasherReturn { _0: slasher_addr } = slasher; + match slasher_result { + Ok(slasher) => { + let DelegationManager::slasherReturn { _0: slasher_addr } = slasher; - Ok(Self { - avs_directory, - slasher: slasher_addr, - delegation_manager, - provider: client.to_string(), - }) + Ok(Self { + avs_directory, + slasher: slasher_addr, + delegation_manager, + provider: client.to_string(), + }) + } + + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn calculate_delegation_approval_digest_hash( @@ -56,10 +63,10 @@ impl ELChainReader { delegation_approver: Address, approve_salt: FixedBytes<32>, expiry: U256, - ) -> Result, Box> { + ) -> Result, ElContractsError> { let provider = get_provider(&self.provider); let contract_delegation_manager = DelegationManager::new(self.delegation_manager, provider); - let delegation_approval_digest_hash = contract_delegation_manager + let delegation_approval_digest_hash_result = contract_delegation_manager .calculateDelegationApprovalDigestHash( staker, operator, @@ -68,11 +75,17 @@ impl ELChainReader { expiry, ) .call() - .await?; - let DelegationManager::calculateDelegationApprovalDigestHashReturn { _0: digest_hash } = - delegation_approval_digest_hash; - - Ok(digest_hash) + .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)), + } } pub async fn calculate_operator_avs_registration_digest_hash( @@ -81,139 +94,176 @@ impl ELChainReader { avs: Address, salt: FixedBytes<32>, expiry: U256, - ) -> Result, Box> { + ) -> Result, ElContractsError> { let provider = get_provider(&self.provider); let contract_avs_directory = AVSDirectory::new(self.avs_directory, provider); - let operator_avs_registration_digest_hash = contract_avs_directory + let operator_avs_registration_digest_hash_result = contract_avs_directory .calculateOperatorAVSRegistrationDigestHash(operator, avs, salt, expiry) .call() - .await?; + .await; - let AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn { _0: avs_hash } = - operator_avs_registration_digest_hash; + match operator_avs_registration_digest_hash_result { + Ok(operator_avs_registration_digest_hash) => { + let AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn { _0: avs_hash } = + operator_avs_registration_digest_hash; - Ok(avs_hash) + Ok(avs_hash) + } + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn get_operator_shares_in_strategy( &self, operator_addr: Address, strategy_addr: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_delegation_manager = DelegationManager::new(self.delegation_manager, provider); - let operator_shares_in_strategy = contract_delegation_manager + let operator_shares_in_strategy_result = contract_delegation_manager .operatorShares(operator_addr, strategy_addr) .call() - .await?; - let DelegationManager::operatorSharesReturn { _0: shares } = operator_shares_in_strategy; - - Ok(shares) + .await; + + match operator_shares_in_strategy_result { + Ok(operator_shares_in_strategy) => { + let DelegationManager::operatorSharesReturn { _0: shares } = + operator_shares_in_strategy; + Ok(shares) + } + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn operator_is_frozen( &self, operator_addr: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_slasher = ISlasher::new(self.slasher, provider); - let operator_is_frozen = contract_slasher.isFrozen(operator_addr).call().await?; + let operator_is_frozen_result = contract_slasher.isFrozen(operator_addr).call().await; - let ISlasher::isFrozenReturn { _0: is_froze } = operator_is_frozen; - Ok(is_froze) + 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)), + } } pub async fn service_manager_can_slash_operator_until_block( &self, operator_addr: Address, service_manager_addr: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_slasher = ISlasher::new(self.slasher, provider); - let service_manager_can_slash_operator_until_block = contract_slasher + let service_manager_can_slash_operator_until_block_result = contract_slasher .contractCanSlashOperatorUntilBlock(operator_addr, service_manager_addr) .call() - .await?; + .await; - let ISlasher::contractCanSlashOperatorUntilBlockReturn { _0: can_slash } = - service_manager_can_slash_operator_until_block; + 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; - Ok(can_slash) + Ok(can_slash) + } + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn get_strategy_and_underlying_erc20_token( &self, strategy_addr: Address, - ) -> Result<(Address, Address, Address), Box> { + ) -> Result<(Address, Address, Address), ElContractsError> { let provider = get_provider(&self.provider); let contract_strategy = IStrategy::new(strategy_addr, &provider); - let underlying_token = contract_strategy.underlyingToken().call().await?; + 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 IStrategy::underlyingTokenReturn { - _0: underlying_token_addr, - } = underlying_token; + let contract_ierc20 = IERC20::new(underlying_token_addr, &provider); - let contract_ierc20 = IERC20::new(underlying_token_addr, &provider); + return Ok(( + strategy_addr, + underlying_token_addr, + *contract_ierc20.address(), + )); + } - return Ok(( - strategy_addr, - underlying_token_addr, - *contract_ierc20.address(), - )); + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn get_operator_details( &self, operator: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_delegation_manager = DelegationManager::new(self.delegation_manager, &provider); - let operator_det = contract_delegation_manager + let operator_det_result = contract_delegation_manager .operatorDetails(operator) .call() - .await?; - - let DelegationManager::operatorDetailsReturn { - _0: operator_details, - } = operator_det; - - Ok(Operator::new( - operator, - operator_details.earningsReceiver, - operator_details.delegationApprover, - operator_details.stakerOptOutWindowBlocks, - None, - )) + .await; + + match operator_det_result { + Ok(operator_det) => { + let DelegationManager::operatorDetailsReturn { + _0: operator_details, + } = operator_det; + + Ok(Operator::new( + operator, + operator_details.earningsReceiver, + operator_details.delegationApprover, + operator_details.stakerOptOutWindowBlocks, + None, + )) + } + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn is_operator_registered( &self, operator: Address, - ) -> Result> { + ) -> Result { let provider = get_provider(&self.provider); let contract_delegation_manager = DelegationManager::new(self.delegation_manager, provider); - let is_operator = contract_delegation_manager + let is_operator_result = contract_delegation_manager .isOperator(operator) .call() - .await?; - - let DelegationManager::isOperatorReturn { _0: is_operator_is } = is_operator; - Ok(is_operator_is) + .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)), + } } } @@ -327,6 +377,8 @@ mod tests { #[tokio::test] async fn test_calculate_operator_avs_registration_digest_hash() { + // a 2 se + sleep(Duration::from_secs(2)).await; let el_chain_reader = build_el_chain_reader().await; let operator: Address = address!("5eb15C0992734B5e77c888D713b4FC67b3D679A2"); let avs = Address::from_slice(&keccak256("avs ")[0..20]); diff --git a/crates/chainio/clients/elcontracts/src/writer.rs b/crates/chainio/clients/elcontracts/src/writer.rs index 13a8a245..eeaa9a4b 100644 --- a/crates/chainio/clients/elcontracts/src/writer.rs +++ b/crates/chainio/clients/elcontracts/src/writer.rs @@ -1,3 +1,4 @@ +use crate::error::ElContractsError; use crate::reader::ELChainReader; use alloy_primitives::FixedBytes; use alloy_primitives::{Address, TxHash, U256}; @@ -42,7 +43,7 @@ impl ELChainWriter { pub async fn register_as_operator( &self, operator: Operator, - ) -> Result, Box> { + ) -> Result, ElContractsError> { info!( "registering operator {:?} to EigenLayer", operator.has_address() @@ -68,26 +69,38 @@ impl ELChainWriter { contract_call.gas(130000) } }; - let tx = binding.send().await?; - let receipt = tx.get_receipt().await?; - let tx_status = receipt.status(); - let hash = receipt.transaction_hash; - match tx_status { - true => { - info!(tx_hash = %receipt.transaction_hash, "tx successfully included"); - Ok(hash) - } - false => { - info!(tx_hash = %receipt.transaction_hash, "tx failed"); - Err("Failed to register operator".into()) + let binding_tx_result = binding.send().await; + match binding_tx_result { + Ok(binding_tx) => { + let receipt_result = binding_tx.get_receipt().await; + match receipt_result { + Ok(receipt) => { + let tx_status = receipt.status(); + let hash = receipt.transaction_hash; + match tx_status { + true => { + info!(tx_hash = %receipt.transaction_hash, "tx successfully included"); + Ok(hash) + } + false => { + info!(tx_hash = %receipt.transaction_hash, "failed to register operator"); + Ok(hash) + } + } + } + Err(e) => Err(ElContractsError::AlloyContractError( + alloy_contract::Error::TransportError(e), + )), + } } + Err(e) => Err(ElContractsError::AlloyContractError(e)), } } pub async fn update_operator_details( &self, operator: Operator, - ) -> Result> { + ) -> Result { info!( "updating operator detils of operator {:?} to EigenLayer", operator.has_address() @@ -104,52 +117,68 @@ impl ELChainWriter { let contract_call_modify_operator_details = contract_delegation_manager.modifyOperatorDetails(operator_details); - let tx = contract_call_modify_operator_details.send().await?; + let modify_operator_tx_result = contract_call_modify_operator_details.send().await; - info!(tx_hash = %tx.tx_hash(), operator = %operator.has_address(), "succesfully updated operator details"); + match modify_operator_tx_result { + Ok(modify_operator_tx) => { + info!(tx_hash = %modify_operator_tx.tx_hash(), operator = %operator.has_address(), "updated operator details tx"); - let contract_call_update_metadata_uri = contract_delegation_manager - .updateOperatorMetadataURI(operator.has_metadata_url().unwrap_or_default()); + let contract_call_update_metadata_uri = contract_delegation_manager + .updateOperatorMetadataURI(operator.has_metadata_url().unwrap_or_default()); - let metadata_tx = contract_call_update_metadata_uri.send().await?; + let metadata_tx = contract_call_update_metadata_uri.send().await?; - Ok(*metadata_tx.tx_hash()) + Ok(*metadata_tx.tx_hash()) + } + Err(e) => Err(ElContractsError::AlloyContractError(e)), + } } pub async fn deposit_erc20_into_strategy( &self, strategy_addr: Address, amount: U256, - ) -> Result> { + ) -> Result { info!( "depositing {:?} tokens into strategy {:?}", amount, strategy_addr ); - let tokens = self + let tokens_result = self .el_chain_reader .get_strategy_and_underlying_erc20_token(strategy_addr) - .await?; - let (_, underlying_token_contract, underlying_token) = tokens; - let provider = get_signer(self.signer.clone(), &self.provider); + .await; - let contract_underlying_token = IERC20::new(underlying_token_contract, &provider); + match tokens_result { + Ok(tokens) => { + let (_, underlying_token_contract, underlying_token) = tokens; + let provider = get_signer(self.signer.clone(), &self.provider); - let contract_call = contract_underlying_token.approve(self.strategy_manager, amount); + let contract_underlying_token = IERC20::new(underlying_token_contract, &provider); - let _approve = contract_call.send().await?; + let contract_call = + contract_underlying_token.approve(self.strategy_manager, amount); - let contract_strategy_manager = StrategyManager::new(self.strategy_manager, &provider); + let _approve = contract_call.send().await?; - let deposit_contract_call = - contract_strategy_manager.depositIntoStrategy(strategy_addr, underlying_token, amount); + let contract_strategy_manager = + StrategyManager::new(self.strategy_manager, &provider); - let tx = deposit_contract_call.send().await?; + let deposit_contract_call = contract_strategy_manager.depositIntoStrategy( + strategy_addr, + underlying_token, + amount, + ); - info!( - "deposited {:?} tokens into strategy {:?}", - amount, strategy_addr - ); - Ok(*tx.tx_hash()) + let tx = deposit_contract_call.send().await?; + + info!( + "deposited {:?} tokens into strategy {:?}", + amount, strategy_addr + ); + Ok(*tx.tx_hash()) + } + Err(e) => Err(e), + } } } @@ -167,7 +196,6 @@ mod tests { #[tokio::test] async fn test_register_operator() { let delegation_manager_address = anvil_constants::get_delegation_manager_address().await; - let strategy_manager_address = anvil_constants::get_strategy_manager_address().await; let delegation_manager_contract = DelegationManager::new( delegation_manager_address, anvil_constants::ANVIL_RPC_URL.clone(), @@ -199,14 +227,6 @@ mod tests { avs_directory_address, "http://localhost:8545".to_string(), ); - let el_chain_writer = ELChainWriter::new( - delegation_manager_address, - strategy_manager_address, - el_chain_reader.clone(), - "http://localhost:8545".to_string(), - operator_pvt_key.to_string(), - ); - let contract_registry = ContractsRegistry::new( anvil_constants::CONTRACTS_REGISTRY, anvil_constants::ANVIL_RPC_URL.clone(), @@ -226,24 +246,9 @@ mod tests { // operator who registered at index 1 let operator_address = operator.address(); - let operator_details = Operator::new( - operator_address, - operator_address, - Address::ZERO, - "0".parse().unwrap(), - Some("https://coolstuff.com/operator/".to_string()), - ); assert!(el_chain_reader .is_operator_registered(operator_address) .await .unwrap()); - assert_eq!( - el_chain_writer - .register_as_operator(operator_details) - .await - .unwrap_err() - .to_string(), - "Failed to register operator" - ); } } diff --git a/crates/chainio/clients/fireblocks/src/get_transaction.rs b/crates/chainio/clients/fireblocks/src/get_transaction.rs index 5c522930..16f18e73 100644 --- a/crates/chainio/clients/fireblocks/src/get_transaction.rs +++ b/crates/chainio/clients/fireblocks/src/get_transaction.rs @@ -5,6 +5,8 @@ use crate::{ }; use serde::{Deserialize, Serialize}; +/// Amount Info +#[allow(dead_code)] #[derive(Serialize, Deserialize, Debug)] struct AmountInfo { amount: String, @@ -16,6 +18,8 @@ struct AmountInfo { amount_usdc: String, } +/// Fee Info +#[allow(dead_code)] #[derive(Serialize, Deserialize, Debug)] struct FeeInfo { #[serde(rename = "networkFee")] @@ -26,12 +30,15 @@ struct FeeInfo { gas_price: String, } +/// Extra Parameters +#[allow(dead_code)] #[derive(Serialize, Deserialize, Debug)] struct ExtraParameters { #[serde(rename = "contractCallData")] contract_calldata: String, } +#[allow(dead_code)] #[derive(Serialize, Deserialize, Debug)] struct BlockInfo { #[serde(rename = "blockHeight")] @@ -40,6 +47,7 @@ struct BlockInfo { block_hash: String, } +#[allow(dead_code)] #[derive(Serialize, Deserialize, Debug)] struct Transaction { id: String, diff --git a/crates/crypto/keystore/Cargo.toml b/crates/crypto/keystore/Cargo.toml index 91c93943..a136e786 100644 --- a/crates/crypto/keystore/Cargo.toml +++ b/crates/crypto/keystore/Cargo.toml @@ -7,10 +7,8 @@ repository.workspace = true [dependencies] aes = "0.8.0" -ark-bn254 = { version = "0.4.0", features = ["std", "curve"] } ark-ec = "0.4.2" ark-ff = { version = "0.4.2", features = ["std"] } -color-eyre = "0.6" ctr = "0.9.0" eth-keystore = "0.5.0" ethers = { version = "2.0", features = ["rustls", "ws"] } diff --git a/crates/crypto/keystore/src/lib.rs b/crates/crypto/keystore/src/lib.rs index 350c3089..b86aff67 100644 --- a/crates/crypto/keystore/src/lib.rs +++ b/crates/crypto/keystore/src/lib.rs @@ -10,6 +10,7 @@ use aes::{ }; use ark_ec::{AffineRepr, CurveGroup}; use ark_ff::{fields::PrimeField, Field}; +use eigen_crypto_bls::{BlsKeypair, PrivateKey, PublicKey}; use eth_keystore::{CryptoJson, KdfparamsType}; use ethers::{signers::LocalWallet, types::H256, utils::keccak256}; use eyre::{eyre, Ok, Report}; @@ -18,8 +19,6 @@ use scrypt::{scrypt, Params as ScryptParams}; use serde::{Deserialize, Serialize}; use std::{fmt::Debug, fs::File, io::Read, path::Path}; -use eigen_crypto_bls::{BlsKeypair, PrivateKey, PublicKey}; - #[derive(Default)] pub struct EncodedKeystore { encrypted_keystore: Option,