Merge asset & scan address names; add EVM tests

Enhance address name resolution to prefer asset-based names and deduplicate results: made ChainAddress Hash+Eq, extended AddressNamesClient to query assets repository, added get_scan_names/get_asset_names helpers and a merge_names routine; added asset_id/asset_name helpers and unit tests. Added a test AddressName::mock utility in primitives testkit and exported it. Moved and expanded EVM simulation tests (some tests moved into decode.rs and client.rs), replaced inline JSON fixtures with external testdata files for various Permit/Permit2 cases, and removed the old tests.rs. These changes improve name lookup accuracy (asset-first) and consolidate EVM test fixtures for maintainability.

Author: gemcoder21

apps/api/src/devices/clients/address_names.rs

@@ -1,7 +1,8 @@
+use std::collections::{HashMap, HashSet};
 use std::error::Error;
 
-use primitives::{AddressName, ChainAddress};
-use storage::{Database, ScanAddressesRepository};
+use primitives::{AddressName, AddressType, Asset, AssetId, ChainAddress, VerificationStatus};
+use storage::{AssetsRepository, Database, ScanAddressesRepository};
 
 #[derive(Clone)]
 pub struct AddressNamesClient {
@@ -14,20 +15,78 @@ impl AddressNamesClient {
     }
 
     pub fn get_address_names(&self, requests: Vec<ChainAddress>) -> Result<Vec<AddressName>, Box<dyn Error + Send + Sync>> {
-        let requests = requests.into_iter().filter(|request| !request.address.is_empty()).collect::<Vec<_>>();
-
+        let requests: Vec<ChainAddress> = requests.into_iter().filter(|request| !request.address.is_empty()).collect();
         if requests.is_empty() {
             return Ok(vec![]);
         }
 
         let queries = requests.iter().map(|request| (request.chain, request.address.as_str())).collect::<Vec<_>>();
-
-        Ok(self
+        let scan_names = self
             .database
             .scan_addresses()?
             .get_scan_addresses(&queries)?
             .into_iter()
-            .filter_map(|x| x.as_primitive())
-            .collect())
+            .filter_map(|row| row.as_primitive())
+            .map(|name| (ChainAddress::new(name.chain, name.address.clone()), name))
+            .collect::<HashMap<_, _>>();
+        let asset_ids = requests
+            .iter()
+            .map(|request| AssetId::from(request.chain, Some(request.address.clone())).to_string())
+            .collect::<Vec<_>>();
+        let asset_names = self
+            .database
+            .assets()?
+            .get_assets(asset_ids)?
+            .into_iter()
+            .filter_map(asset_entry)
+            .collect::<HashMap<_, _>>();
+
+        Ok(map_requests(requests, &scan_names, &asset_names))
+    }
+}
+
+fn map_requests(requests: Vec<ChainAddress>, scan_names: &HashMap<ChainAddress, AddressName>, asset_names: &HashMap<ChainAddress, AddressName>) -> Vec<AddressName> {
+    requests
+        .into_iter()
+        .filter_map(|request| asset_names.get(&request).or_else(|| scan_names.get(&request)).cloned())
+        .scan(HashSet::new(), |seen, name| {
+            seen.insert(ChainAddress::new(name.chain, name.address.clone())).then_some(name)
+        })
+        .collect()
+}
+
+fn asset_entry(asset: Asset) -> Option<(ChainAddress, AddressName)> {
+    let address = asset.token_id?;
+
+    Some((
+        ChainAddress::new(asset.chain, address.clone()),
+        AddressName {
+            chain: asset.chain,
+            address,
+            name: asset.name,
+            address_type: Some(AddressType::Contract),
+            status: VerificationStatus::Verified,
+        },
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use super::map_requests;
+    use primitives::{AddressName, AddressType, Chain, ChainAddress, VerificationStatus};
+
+    #[test]
+    fn test_map_requests_prefers_asset_then_scan() {
+        let asset_request = ChainAddress::new(Chain::Ethereum, "0xdAC17F958D2ee523a2206206994597C13D831ec7".to_string());
+        let scan_request = ChainAddress::new(Chain::Ethereum, "0x123".to_string());
+        let asset_name = AddressName::mock("0xdAC17F958D2ee523a2206206994597C13D831ec7", "USDT", AddressType::Contract, VerificationStatus::Verified);
+        let scan_name = AddressName::mock("0x123", "Legacy Name", AddressType::Address, VerificationStatus::Unverified);
+
+        let scan_names = HashMap::from([(asset_request.clone(), scan_name.clone()), (scan_request.clone(), scan_name.clone())]);
+        let asset_names = HashMap::from([(asset_request.clone(), asset_name.clone())]);
+
+        assert_eq!(map_requests(vec![asset_request, scan_request], &scan_names, &asset_names), vec![asset_name, scan_name]);
     }
 }

crates/primitives/src/chain_address.rs

@@ -5,7 +5,7 @@ use typeshare::typeshare;
 
 use crate::Chain;
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Hash)]
 #[typeshare(swift = "Equatable, Hashable, Sendable")]
 pub struct ChainAddress {
     pub chain: Chain,

crates/primitives/src/testkit/address_name_mock.rs

@@ -0,0 +1,13 @@
+use crate::{AddressName, AddressType, Chain, VerificationStatus};
+
+impl AddressName {
+    pub fn mock(address: &str, name: &str, address_type: AddressType, status: VerificationStatus) -> Self {
+        Self {
+            chain: Chain::Ethereum,
+            address: address.to_string(),
+            name: name.to_string(),
+            address_type: Some(address_type),
+            status,
+        }
+    }
+}

crates/primitives/src/testkit/mod.rs

@@ -1,3 +1,4 @@
+pub mod address_name_mock;
 pub mod asset_mock;
 pub mod delegation_mock;
 pub mod device_mock;

crates/signer/src/eip712/mod.rs

@@ -11,45 +11,7 @@ mod tests {
 
     #[test]
     fn hash_matches_reference_vector() {
-        let json = r#"
-        {
-            "types": {
-                "EIP712Domain": [
-                    { "name": "name", "type": "string" },
-                    { "name": "version", "type": "string" },
-                    { "name": "chainId", "type": "uint256" },
-                    { "name": "verifyingContract", "type": "address" }
-                ],
-                "Person": [
-                    { "name": "name", "type": "string" },
-                    { "name": "wallet", "type": "address" }
-                ],
-                "Mail": [
-                    { "name": "from", "type": "Person" },
-                    { "name": "to", "type": "Person" },
-                    { "name": "contents", "type": "string" }
-                ]
-            },
-            "primaryType": "Mail",
-            "domain": {
-                "name": "Ether Mail",
-                "version": "1",
-                "chainId": 1,
-                "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
-            },
-            "message": {
-                "from": {
-                    "name": "Cow",
-                    "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
-                },
-                "to": {
-                    "name": "Bob",
-                    "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
-                },
-                "contents": "Hello, Bob!"
-            }
-        }
-        "#;
+        let json = include_str!("../../testdata/eip712_reference_vector.json");
 
         let our_hash = hash_typed_data(json).expect("hash succeeds");
         let expected = <[u8; 32]>::from_hex("be609aee343fb3c4b28e1df9e632fca64fcfaede20f02e86244efddf30957bd2").expect("valid hex");
@@ -66,48 +28,7 @@ mod tests {
 
     #[test]
     fn hash_handles_arrays_and_nested_types() {
-        let json = r#"
-        {
-            "types": {
-                "EIP712Domain": [
-                    { "name": "name", "type": "string" },
-                    { "name": "version", "type": "string" },
-                    { "name": "chainId", "type": "uint256" },
-                    { "name": "verifyingContract", "type": "address" }
-                ],
-                "Inner": [
-                    { "name": "flag", "type": "bool" },
-                    { "name": "payload", "type": "bytes32" }
-                ],
-                "Group": [
-                    { "name": "members", "type": "address[]" },
-                    { "name": "name", "type": "string" },
-                    { "name": "nested", "type": "Inner" },
-                    { "name": "weights", "type": "uint64[3]" }
-                ]
-            },
-            "primaryType": "Group",
-            "domain": {
-                "name": "Test",
-                "version": "1",
-                "chainId": 31337,
-                "verifyingContract": "0x0000000000000000000000000000000000000001"
-            },
-            "message": {
-                "members": [
-                    "0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1",
-                    "0xffcf8fdee72ac11b5c542428b35eef5769c409f0",
-                    "0x627306090abab3a6e1400e9345bc60c78a8bef57"
-                ],
-                "name": "Team Rocket",
-                "nested": {
-                    "flag": true,
-                    "payload": "0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
-                },
-                "weights": [ "1", "2", "3" ]
-            }
-        }
-        "#;
+        let json = include_str!("../../testdata/eip712_arrays_nested.json");
 
         let digest = hash_typed_data(json).expect("hash succeeds");
         let expected = <[u8; 32]>::from_hex("6acbc18af9d2decca3d38571c2f595b1ebb1b93e9e7b046632df71f6ceb217f9").expect("valid hex");
@@ -116,45 +37,15 @@ mod tests {
 
     #[test]
     fn hash_rejects_missing_message() {
-        let json = r#"
-        {
-            "types": {
-                "EIP712Domain": [],
-                "Simple": [
-                    { "name": "value", "type": "uint256" }
-                ]
-            },
-            "primaryType": "Simple",
-            "domain": {},
-            "message": null
-        }
-        "#;
+        let json = include_str!("../../testdata/eip712_missing_message.json");
 
         let err = hash_typed_data(json).expect_err("missing message returns error");
         assert!(err.to_string().contains("missing message"));
     }
 
     #[test]
     fn hash_supports_signed_integers() {
-        let json = r#"
-        {
-            "types": {
-                "EIP712Domain": [],
-                "Payload": [
-                    { "name": "balance", "type": "int256" },
-                    { "name": "delta", "type": "int32" },
-                    { "name": "active", "type": "bool" }
-                ]
-            },
-            "primaryType": "Payload",
-            "domain": {},
-            "message": {
-                "balance": "-0x0100",
-                "delta": -42,
-                "active": false
-            }
-        }
-        "#;
+        let json = include_str!("../../testdata/eip712_signed_integers.json");
 
         let digest = hash_typed_data(json).expect("hash succeeds");
         let expected = <[u8; 32]>::from_hex("10e6c8b7c51b08488a421a5492d4524439470010eb2f8c80c22b9d918d79a5a9").expect("valid hex");

crates/signer/testdata/eip712_arrays_nested.json

@@ -0,0 +1,40 @@
+{
+  "types": {
+    "EIP712Domain": [
+      { "name": "name", "type": "string" },
+      { "name": "version", "type": "string" },
+      { "name": "chainId", "type": "uint256" },
+      { "name": "verifyingContract", "type": "address" }
+    ],
+    "Inner": [
+      { "name": "flag", "type": "bool" },
+      { "name": "payload", "type": "bytes32" }
+    ],
+    "Group": [
+      { "name": "members", "type": "address[]" },
+      { "name": "name", "type": "string" },
+      { "name": "nested", "type": "Inner" },
+      { "name": "weights", "type": "uint64[3]" }
+    ]
+  },
+  "primaryType": "Group",
+  "domain": {
+    "name": "Test",
+    "version": "1",
+    "chainId": 31337,
+    "verifyingContract": "0x0000000000000000000000000000000000000001"
+  },
+  "message": {
+    "members": [
+      "0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1",
+      "0xffcf8fdee72ac11b5c542428b35eef5769c409f0",
+      "0x627306090abab3a6e1400e9345bc60c78a8bef57"
+    ],
+    "name": "Team Rocket",
+    "nested": {
+      "flag": true,
+      "payload": "0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"
+    },
+    "weights": ["1", "2", "3"]
+  }
+}

crates/signer/testdata/eip712_missing_message.json

@@ -0,0 +1,11 @@
+{
+  "types": {
+    "EIP712Domain": [],
+    "Simple": [
+      { "name": "value", "type": "uint256" }
+    ]
+  },
+  "primaryType": "Simple",
+  "domain": {},
+  "message": null
+}

crates/signer/testdata/eip712_reference_vector.json

@@ -0,0 +1,37 @@
+{
+  "types": {
+    "EIP712Domain": [
+      { "name": "name", "type": "string" },
+      { "name": "version", "type": "string" },
+      { "name": "chainId", "type": "uint256" },
+      { "name": "verifyingContract", "type": "address" }
+    ],
+    "Person": [
+      { "name": "name", "type": "string" },
+      { "name": "wallet", "type": "address" }
+    ],
+    "Mail": [
+      { "name": "from", "type": "Person" },
+      { "name": "to", "type": "Person" },
+      { "name": "contents", "type": "string" }
+    ]
+  },
+  "primaryType": "Mail",
+  "domain": {
+    "name": "Ether Mail",
+    "version": "1",
+    "chainId": 1,
+    "verifyingContract": "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"
+  },
+  "message": {
+    "from": {
+      "name": "Cow",
+      "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
+    },
+    "to": {
+      "name": "Bob",
+      "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
+    },
+    "contents": "Hello, Bob!"
+  }
+}

crates/signer/testdata/eip712_signed_integers.json

@@ -0,0 +1,17 @@
+{
+  "types": {
+    "EIP712Domain": [],
+    "Payload": [
+      { "name": "balance", "type": "int256" },
+      { "name": "delta", "type": "int32" },
+      { "name": "active", "type": "bool" }
+    ]
+  },
+  "primaryType": "Payload",
+  "domain": {},
+  "message": {
+    "balance": "-0x0100",
+    "delta": -42,
+    "active": false
+  }
+}