chore: bump version to 0.4.0 and enhance codebase quality

- Upgrade workspace version from 0.3.4 to 0.4.0
- Remove chrono dependency (unused)
- Remove prohibited comment style from fetcher.rs
- Add comprehensive unit tests for client, error, networks, and types modules
- Add builder methods for ServiceEndpoint and FeedbackInput types
- Change reputation API to accept slice references instead of owned Vec for client_addresses
- Replace generic contract error with specific MissingRegisteredEvent error

Author: gitctrlx

Cargo.lock

@@ -4,21 +4,20 @@ default-members = ["erc8004"]
 resolver = "3"
 
 [workspace.package]
-version = "0.3.4"
+version = "0.4.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/qntx/erc8004"
 description = "ERC-8004 Trustless Agents Rust SDK."
 
 [workspace.dependencies]
-erc8004 = { version = "0.3", path = "erc8004" }
-erc8004-events = { version = "0.3", path = "erc8004-events" }
+erc8004 = { version = "0.4", path = "erc8004" }
+erc8004-events = { version = "0.4", path = "erc8004-events" }
 
 alloy = { version = "1.8.3", features = ["full"] }
 anyhow = "1.0.102"
 arrow-array = "58.1.0"
 arrow-schema = "58.1.0"
-chrono = { version = "0.4.44", features = ["serde"] }
 clap = { version = "4.6.0", features = ["derive"] }
 parquet = { version = "58.1.0", features = ["arrow"] }
 serde = { version = "1.0.228", features = ["derive"] }

Cargo.toml

@@ -84,8 +84,6 @@ impl Batcher {
     }
 }
 
-// ── Error classification ─────────────────────────────────────────────
-
 /// Broad classification of RPC errors.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum RpcErrorKind {

erc8004-events/src/fetcher.rs

@@ -37,9 +37,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     // Get the aggregated summary (filtering by known clients to avoid Sybil).
-    let summary = reputation
-        .get_summary(agent_id, clients.clone(), "", "")
-        .await?;
+    let summary = reputation.get_summary(agent_id, &clients, "", "").await?;
 
     println!(
         "Summary: count={}, value={} (decimals={})",

erc8004/examples/reputation_summary.rs

@@ -187,3 +187,76 @@ impl<P: Provider> Erc8004<P> {
         self.validation_address
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use alloy::primitives::address;
+    use alloy::providers::ProviderBuilder;
+
+    use super::*;
+    use crate::networks::Network;
+
+    fn test_client() -> Erc8004<impl Provider> {
+        let provider = ProviderBuilder::new().connect_http("https://localhost:1".parse().unwrap());
+        Erc8004::new(provider)
+    }
+
+    #[test]
+    fn test_new_has_no_addresses() {
+        let client = test_client();
+        assert!(client.identity_address().is_none());
+        assert!(client.reputation_address().is_none());
+        assert!(client.validation_address().is_none());
+    }
+
+    #[test]
+    fn test_with_network_configures_handles() {
+        let client = test_client().with_network(Network::EthereumMainnet);
+        let addrs = Network::EthereumMainnet.addresses();
+        assert_eq!(client.identity_address(), Some(addrs.identity));
+        assert_eq!(client.reputation_address(), Some(addrs.reputation));
+        assert!(client.identity().is_ok());
+        assert!(client.reputation().is_ok());
+    }
+
+    #[test]
+    fn test_with_individual_addresses_stored_independently() {
+        let id = address!("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+        let rep = address!("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+        let val = address!("cccccccccccccccccccccccccccccccccccccccc");
+        let client = test_client()
+            .with_identity_address(id)
+            .with_reputation_address(rep)
+            .with_validation_address(val);
+        assert_eq!(client.identity_address(), Some(id));
+        assert_eq!(client.reputation_address(), Some(rep));
+        assert_eq!(client.validation_address(), Some(val));
+    }
+
+    #[test]
+    fn test_unconfigured_registries_return_error() {
+        let client = test_client();
+        for (label, result) in [
+            ("identity", client.identity().err()),
+            ("reputation", client.reputation().err()),
+            ("validation", client.validation().err()),
+        ] {
+            let msg = result.map_or_else(|| unreachable!("{label} should fail"), |e| e.to_string());
+            assert!(
+                msg.contains("not configured"),
+                "{label}: expected 'not configured', got: {msg}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_with_addresses_struct() {
+        let addrs = NetworkAddresses {
+            identity: address!("1111111111111111111111111111111111111111"),
+            reputation: address!("2222222222222222222222222222222222222222"),
+        };
+        let client = test_client().with_addresses(addrs);
+        assert_eq!(client.identity_address(), Some(addrs.identity));
+        assert_eq!(client.reputation_address(), Some(addrs.reputation));
+    }
+}

erc8004/src/client.rs

@@ -45,6 +45,10 @@ pub enum Erc8004Error {
         source: alloy::hex::FromHexError,
     },
 
+    /// A registration transaction succeeded but emitted no `Registered` event.
+    #[error("transaction receipt contained no Registered event")]
+    MissingRegisteredEvent,
+
     /// The identity registry address returned by Reputation/Validation
     /// does not match the configured identity registry.
     #[error("identity registry mismatch: expected {expected}, got {actual}")]
@@ -58,3 +62,50 @@ pub enum Erc8004Error {
 
 /// A convenience type alias used throughout the SDK.
 pub type Result<T> = core::result::Result<T, Erc8004Error>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_registry_not_configured_display() {
+        let err = Erc8004Error::RegistryNotConfigured {
+            registry: "identity",
+        };
+        assert_eq!(err.to_string(), "registry not configured: identity");
+    }
+
+    #[test]
+    fn test_agent_not_found_display() {
+        let err = Erc8004Error::AgentNotFound {
+            agent_id: alloy::primitives::U256::from(42),
+        };
+        assert_eq!(err.to_string(), "agent 42 does not exist");
+    }
+
+    #[test]
+    fn test_missing_registered_event_display() {
+        let err = Erc8004Error::MissingRegisteredEvent;
+        assert_eq!(
+            err.to_string(),
+            "transaction receipt contained no Registered event"
+        );
+    }
+
+    #[test]
+    fn test_identity_registry_mismatch_display() {
+        let expected = Address::ZERO;
+        let actual = Address::repeat_byte(0x01);
+        let err = Erc8004Error::IdentityRegistryMismatch { expected, actual };
+        assert_eq!(
+            err.to_string(),
+            format!("identity registry mismatch: expected {expected}, got {actual}")
+        );
+    }
+
+    #[test]
+    fn test_error_is_send_sync() {
+        fn assert_send_sync<T: Send + Sync>() {}
+        assert_send_sync::<Erc8004Error>();
+    }
+}

erc8004/src/error.rs

@@ -267,10 +267,6 @@ impl<P: Provider> Identity<P> {
                     .ok()
                     .map(|e| e.inner.data.agentId)
             })
-            .ok_or(Erc8004Error::Contract(
-                alloy::contract::Error::UnknownFunction(
-                    "register: no Registered event found".to_owned(),
-                ),
-            ))
+            .ok_or(Erc8004Error::MissingRegisteredEvent)
     }
 }

erc8004/src/identity.rs

@@ -218,3 +218,75 @@ impl Network {
         format!("eip155:{}:{}", self.chain_id(), self.addresses().identity)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_all_has_no_duplicate_chain_ids() {
+        let mut ids: Vec<u64> = Network::ALL.iter().map(|n| n.chain_id()).collect();
+        ids.sort_unstable();
+        let before = ids.len();
+        ids.dedup();
+        assert_eq!(
+            before,
+            ids.len(),
+            "Network::ALL contains duplicate chain IDs"
+        );
+    }
+
+    #[test]
+    fn test_chain_id_round_trip() {
+        for &network in Network::ALL {
+            let id = network.chain_id();
+            assert_eq!(
+                Network::from_chain_id(id),
+                Some(network),
+                "from_chain_id({id}) should return the original variant"
+            );
+        }
+    }
+
+    #[test]
+    fn test_from_chain_id_unknown_returns_none() {
+        assert_eq!(Network::from_chain_id(999_999_999), None);
+    }
+
+    #[test]
+    fn test_create2_mainnet_addresses_are_consistent() {
+        let reference = Network::EthereumMainnet.addresses();
+        for &network in Network::ALL {
+            let addrs = network.addresses();
+            if addrs.identity != reference.identity {
+                continue;
+            }
+            assert_eq!(
+                addrs.reputation,
+                reference.reputation,
+                "chain {} has matching identity but mismatched reputation",
+                network.chain_id()
+            );
+        }
+    }
+
+    #[test]
+    fn test_testnet_addresses_differ_from_mainnet() {
+        let mainnet = Network::EthereumMainnet.addresses();
+        let testnet = Network::EthereumSepolia.addresses();
+        assert_ne!(mainnet.identity, testnet.identity);
+        assert_ne!(mainnet.reputation, testnet.reputation);
+    }
+
+    #[test]
+    fn test_agent_registry_prefix_format() {
+        let network = Network::EthereumMainnet;
+        let prefix = network.agent_registry_prefix();
+        let expected = format!(
+            "eip155:{}:{}",
+            network.chain_id(),
+            network.addresses().identity
+        );
+        assert_eq!(prefix, expected);
+    }
+}

erc8004/src/networks.rs

@@ -146,7 +146,7 @@ impl<P: Provider> Reputation<P> {
     pub async fn read_all_feedback(
         &self,
         agent_id: U256,
-        client_addresses: Vec<Address>,
+        client_addresses: &[Address],
         tag1: &str,
         tag2: &str,
         include_revoked: bool,
@@ -155,7 +155,7 @@ impl<P: Provider> Reputation<P> {
         Ok(contract
             .readAllFeedback(
                 agent_id,
-                client_addresses,
+                client_addresses.to_vec(),
                 tag1.to_owned(),
                 tag2.to_owned(),
                 include_revoked,
@@ -175,13 +175,18 @@ impl<P: Provider> Reputation<P> {
     pub async fn get_summary(
         &self,
         agent_id: U256,
-        client_addresses: Vec<Address>,
+        client_addresses: &[Address],
         tag1: &str,
         tag2: &str,
     ) -> Result<ReputationSummary> {
         let contract = ReputationRegistry::new(self.address, &self.provider);
         let r = contract
-            .getSummary(agent_id, client_addresses, tag1.to_owned(), tag2.to_owned())
+            .getSummary(
+                agent_id,
+                client_addresses.to_vec(),
+                tag1.to_owned(),
+                tag2.to_owned(),
+            )
             .call()
             .await?;
         Ok(ReputationSummary {
@@ -224,11 +229,16 @@ impl<P: Provider> Reputation<P> {
         agent_id: U256,
         client_address: Address,
         feedback_index: u64,
-        responders: Vec<Address>,
+        responders: &[Address],
     ) -> Result<u64> {
         let contract = ReputationRegistry::new(self.address, &self.provider);
         Ok(contract
-            .getResponseCount(agent_id, client_address, feedback_index, responders)
+            .getResponseCount(
+                agent_id,
+                client_address,
+                feedback_index,
+                responders.to_vec(),
+            )
             .call()
             .await?)
     }