fix: all warnings from cargo

Author: rymnc

committer/src/setup.rs

@@ -489,7 +489,7 @@ pub async fn l1_adapter(
 
 pub async fn eigen_adapter(
     config: &EigenDaConfig,
-    internal_config: &config::Internal,
+    _internal_config: &config::Internal,
 ) -> Result<EigenDA> {
     // Configure with appropriate throughput values
     // because testing showed that the time window in which thottling is calculated allows for

e2e/helpers/src/bin/start_committer.rs

@@ -1,13 +1,12 @@
-use alloy::network::TxSigner;
 use anyhow::Result;
 use std::time::Duration;
 use tokio::time::sleep;
 use url::Url;
 
 use e2e_helpers::{
     committer::Committer,
-    eth_node::{ContractArgs, DeployedContract, EthNode, EthNodeProcess},
-    kms::{Kms, KmsKey, KmsProcess},
+    eth_node::{EthNode, EthNodeProcess},
+    kms::{Kms, KmsProcess},
     whole_stack::{create_and_fund_kms_signers, deploy_contract},
 };
 
@@ -22,14 +21,14 @@ async fn main() -> Result<()> {
     let request_timeout = Duration::from_secs(5);
     let max_fee = 1_000_000_000_000;
 
-    let (contract_args, deployed_contract) =
+    let (_contract_args, deployed_contract) =
         deploy_contract(&eth_node, eth_signers.clone(), max_fee, request_timeout).await?;
 
     let db = start_db().await?;
 
     let fuel_node_url = Url::parse("http://localhost:4000").unwrap();
 
-    let committer = {
+    let _committer = {
         let committer_builder = Committer::default()
             .with_show_logs(true)
             .with_eth_rpc((eth_node).ws_url())

e2e/helpers/src/eth_node/state_contract.rs

@@ -2,7 +2,7 @@ const FOUNDRY_PROJECT: &str = concat!(env!("OUT_DIR"), "/foundry");
 use std::time::Duration;
 
 use alloy::{
-    network::{EthereumWallet, TxSigner},
+    network::EthereumWallet,
     primitives::{Bytes, TxKind},
     providers::{Provider, ProviderBuilder, WsConnect},
     rpc::types::TransactionRequest,

e2e/tests/tests/eigen_kms.rs

@@ -4,26 +4,22 @@ use e2e_helpers::kms::Kms;
 use e2e_helpers::kms::KmsProcess;
 use eigenda::EigenDAClient;
 use eigenda::Throughput;
-use ethereum_types::H160;
 use k256::ecdsa::SigningKey as K256SigningKey;
 use rand::RngCore;
 use rand::rngs::OsRng;
 use rust_eigenda_signers::Message;
 use rust_eigenda_signers::PublicKey;
 use rust_eigenda_signers::RecoverableSignature;
-use rust_eigenda_signers::SecretKey;
 use rust_eigenda_signers::signers::private_key::Signer as PrivateKeySigner;
 use rust_eigenda_v2_client::rust_eigenda_signers::Sign;
-use rust_eigenda_v2_client::utils::SecretUrl;
 use secp256k1::Secp256k1;
 use services::types::DispersalStatus;
 use sha2::{Digest, Sha256};
 
 use signers::eigen::kms::Signer;
-use std::num::NonZero;
 use std::num::NonZeroU32;
-use std::{env, error::Error, str::FromStr, sync::Arc, time::Duration};
-use tracing::{error, info, instrument};
+use std::{env, str::FromStr, time::Duration};
+use tracing::{error, info};
 use tracing_subscriber::EnvFilter;
 use url::Url;
 

packages/adapters/eigenda/src/codec.rs

@@ -30,38 +30,38 @@ pub fn convert_by_padding_empty_byte(data: &[u8]) -> Vec<u8> {
     valid_data
 }
 
-pub fn remove_empty_byte_from_padded_bytes(data: &[u8]) -> Vec<u8> {
-    const PUT_SIZE: usize = BYTES_PER_SYMBOL - 1; // 31
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let data_size = data.len();
-    let data_len = (data_size + BYTES_PER_SYMBOL - 1) / BYTES_PER_SYMBOL;
+    fn remove_empty_byte_from_padded_bytes(data: &[u8]) -> Vec<u8> {
+        const PUT_SIZE: usize = BYTES_PER_SYMBOL - 1; // 31
 
-    let mut valid_data = vec![0u8; data_len * PUT_SIZE];
-    let mut valid_len = data_len * PUT_SIZE;
+        let data_size = data.len();
+        let data_len = (data_size + BYTES_PER_SYMBOL - 1) / BYTES_PER_SYMBOL;
 
-    for i in 0..data_len {
-        let start = i * BYTES_PER_SYMBOL + 1;
-        let end = (i + 1) * BYTES_PER_SYMBOL;
-        let end = end.min(data_size);
+        let mut valid_data = vec![0u8; data_len * PUT_SIZE];
+        let mut valid_len = data_len * PUT_SIZE;
 
-        let output_start = i * PUT_SIZE;
-        let data_slice = &data[start..end];
-        let output_slice = &mut valid_data[output_start..output_start + data_slice.len()];
-        output_slice.copy_from_slice(data_slice);
+        for i in 0..data_len {
+            let start = i * BYTES_PER_SYMBOL + 1;
+            let end = (i + 1) * BYTES_PER_SYMBOL;
+            let end = end.min(data_size);
 
-        if end == data_size {
-            valid_len = output_start + data_slice.len();
-            break;
-        }
-    }
+            let output_start = i * PUT_SIZE;
+            let data_slice = &data[start..end];
+            let output_slice = &mut valid_data[output_start..output_start + data_slice.len()];
+            output_slice.copy_from_slice(data_slice);
 
-    valid_data.truncate(valid_len);
-    valid_data
-}
+            if end == data_size {
+                valid_len = output_start + data_slice.len();
+                break;
+            }
+        }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+        valid_data.truncate(valid_len);
+        valid_data
+    }
 
     #[test]
     fn test_round_trip() {

packages/adapters/eigenda/src/lib.rs

@@ -2,7 +2,6 @@ mod bindings;
 mod codec;
 mod connector;
 mod error;
-mod signer;
 
 use bindings::BlobStatus;
 pub use connector::*;

packages/adapters/eigenda/src/signer.rs

@@ -1,13 +1,7 @@
-use std::{num::NonZeroU32, ops::RangeInclusive, str::FromStr, time::Duration};
+use std::{num::NonZeroU32, ops::RangeInclusive, time::Duration};
 
 use ::metrics::{HealthChecker, RegistersMetrics, prometheus::core::Collector};
-use alloy::{
-    consensus::SignableTransaction,
-    network::TxSigner,
-    primitives::{Address, B256, ChainId},
-    rpc::types::FeeHistory,
-    signers::{Signature, aws::AwsSigner, local::PrivateKeySigner},
-};
+use alloy::{network::TxSigner, primitives::Address, rpc::types::FeeHistory, signers::Signature};
 use delegate::delegate;
 use serde::Deserialize;
 use services::{

packages/adapters/eth/src/websocket.rs

@@ -1,11 +1,7 @@
-use alloy::network::TxSigner;
 use anyhow::Context;
 use async_trait::async_trait;
-use aws_config::{Region, SdkConfig, default_provider::credentials::DefaultCredentialsChain};
-#[cfg(feature = "test-helpers")]
-use aws_sdk_kms::config::Credentials;
+use aws_sdk_kms::Client as InnerClient;
 use aws_sdk_kms::primitives::Blob;
-use aws_sdk_kms::{Client as InnerClient, config::BehaviorVersion};
 use k256::{
     ecdsa::{RecoveryId, Signature, VerifyingKey},
     pkcs8::DecodePublicKey,
@@ -18,7 +14,6 @@ pub struct Signer {
     key_id: String,
     client: InnerClient,
     public_key: rust_eigenda_signers::PublicKey,
-    k256_verifying_key: VerifyingKey,
 }
 
 impl Signer {
@@ -47,7 +42,6 @@ impl Signer {
             key_id,
             client,
             public_key: secp_pub_key,
-            k256_verifying_key: k256_pub_key,
         })
     }
 
@@ -172,28 +166,3 @@ impl eigenda::Sign for crate::eigen::kms::Signer {
         self.public_key.into()
     }
 }
-
-// Helper function to determine k256 recovery ID.
-// Necessary because KMS returns a DER signature, and we need to extract R, S, and find V.
-fn determine_k256_recovery_id(
-    sig: &k256::ecdsa::Signature,
-    message_hash: &[u8; 32],
-    expected_pubkey: &VerifyingKey,
-) -> anyhow::Result<k256::ecdsa::RecoveryId> {
-    let recid_0 = k256::ecdsa::RecoveryId::from_byte(0).context("Bad RecoveryId byte 0")?;
-    let recid_1 = k256::ecdsa::RecoveryId::from_byte(1).context("Bad RecoveryId byte 1")?;
-
-    if let Ok(recovered_key) = VerifyingKey::recover_from_prehash(message_hash, sig, recid_0) {
-        if &recovered_key == expected_pubkey {
-            return Ok(recid_0);
-        }
-    }
-
-    if let Ok(recovered_key) = VerifyingKey::recover_from_prehash(message_hash, sig, recid_1) {
-        if &recovered_key == expected_pubkey {
-            return Ok(recid_1);
-        }
-    }
-
-    anyhow::bail!("Could not recover correct public key from k256 signature")
-}

packages/adapters/signers/src/eigen/kms.rs

@@ -16,8 +16,7 @@ use services::{
     types::{
         BlockSubmission, BlockSubmissionTx, BundleCost, CompressedFuelBlock, DateTime,
         DispersalStatus, EigenDASubmission, Fragment, L1Tx, NonEmpty, NonNegative,
-        TransactionCostUpdate, TransactionState, Utc,
-        storage::{BundleFragment, SequentialFuelBlocks},
+        TransactionCostUpdate, TransactionState, Utc, storage::BundleFragment,
     },
 };