test: add 27 unit tests across 5 modules for hackathon judging

Cover ABI decoding (uint256 boundaries, string encoding, fallback),
risk scoring (features, holders, bridge, full integration), NTT
compatibility (mode, decimals, rebasing), bytecode analysis
(capabilities, fee detection, boundaries), and deployment config
(JSON output, CLI commands, rate limit defaults).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Jpatching

src/analyzers/compatibility.rs

@@ -264,4 +264,137 @@ mod tests {
             .iter()
             .any(|i| i.code == "FEE_ON_TRANSFER" && i.severity == IssueSeverity::Error));
     }
+
+    // ── Mode determination ─────────────────────────────────
+
+    #[test]
+    fn test_determine_mode_burning() {
+        let caps = TokenCapabilities {
+            has_burn: true,
+            ..Default::default()
+        };
+        assert_eq!(
+            CompatibilityChecker::determine_mode(&caps),
+            NttMode::Burning
+        );
+    }
+
+    #[test]
+    fn test_determine_mode_locking() {
+        assert_eq!(
+            CompatibilityChecker::determine_mode(&TokenCapabilities::default()),
+            NttMode::Locking
+        );
+    }
+
+    // ── Decimal handling ───────────────────────────────────
+
+    #[test]
+    fn test_no_trimming_for_6_decimals() {
+        let token = TokenInfo {
+            address: "0x0".to_string(),
+            chain: Chain::Ethereum,
+            name: "Test".to_string(),
+            symbol: "TEST".to_string(),
+            decimals: 6,
+            total_supply: "1000000".to_string(),
+        };
+        let result = CompatibilityChecker::check(
+            &token,
+            &TokenCapabilities::default(),
+            &BytecodeAnalysis::default(),
+        );
+        assert!(!result.decimal_trimming_required);
+        assert_eq!(result.solana_decimals, 6);
+    }
+
+    #[test]
+    fn test_trimming_for_9_decimals() {
+        let token = TokenInfo {
+            address: "0x0".to_string(),
+            chain: Chain::Ethereum,
+            name: "Test".to_string(),
+            symbol: "TEST".to_string(),
+            decimals: 9,
+            total_supply: "1000000".to_string(),
+        };
+        let result = CompatibilityChecker::check(
+            &token,
+            &TokenCapabilities::default(),
+            &BytecodeAnalysis::default(),
+        );
+        assert!(result.decimal_trimming_required);
+        assert_eq!(result.solana_decimals, 8);
+    }
+
+    // ── Rebasing → incompatible ────────────────────────────
+
+    #[test]
+    fn test_rebasing_incompatible() {
+        let token = TokenInfo {
+            address: "0x0".to_string(),
+            chain: Chain::Ethereum,
+            name: "stETH".to_string(),
+            symbol: "stETH".to_string(),
+            decimals: 18,
+            total_supply: "1000000".to_string(),
+        };
+        let caps = TokenCapabilities {
+            is_rebasing: true,
+            ..Default::default()
+        };
+        let result = CompatibilityChecker::check(&token, &caps, &BytecodeAnalysis::default());
+        assert!(!result.is_compatible);
+        assert!(result
+            .issues
+            .iter()
+            .any(|i| i.code == "REBASING" && i.severity == IssueSeverity::Error));
+    }
+
+    // ── Combined features: pausable + blacklistable ────────
+
+    #[test]
+    fn test_pausable_blacklistable_compatible_with_warnings() {
+        let token = TokenInfo {
+            address: "0x0".to_string(),
+            chain: Chain::Ethereum,
+            name: "Test".to_string(),
+            symbol: "TEST".to_string(),
+            decimals: 6,
+            total_supply: "1000000".to_string(),
+        };
+        let caps = TokenCapabilities {
+            has_pause: true,
+            has_blacklist: true,
+            ..Default::default()
+        };
+        let result = CompatibilityChecker::check(&token, &caps, &BytecodeAnalysis::default());
+        assert!(result.is_compatible); // warnings don't block
+        assert!(result.issues.iter().any(|i| i.code == "PAUSABLE"));
+        assert!(result.issues.iter().any(|i| i.code == "BLACKLIST"));
+    }
+
+    // ── Burnable token produces Info issue ──────────────────
+
+    #[test]
+    fn test_burnable_info_issue() {
+        let token = TokenInfo {
+            address: "0x0".to_string(),
+            chain: Chain::Ethereum,
+            name: "Test".to_string(),
+            symbol: "TEST".to_string(),
+            decimals: 6,
+            total_supply: "1000000".to_string(),
+        };
+        let caps = TokenCapabilities {
+            has_burn: true,
+            ..Default::default()
+        };
+        let result = CompatibilityChecker::check(&token, &caps, &BytecodeAnalysis::default());
+        assert!(result.is_compatible);
+        assert!(result
+            .issues
+            .iter()
+            .any(|i| i.code == "BURNABLE" && i.severity == IssueSeverity::Info));
+    }
 }

src/analyzers/evm/bytecode.rs

@@ -209,4 +209,84 @@ mod tests {
             BytecodeComplexity::Complex
         );
     }
+
+    // ── Capability detection ───────────────────────────────
+
+    #[test]
+    fn test_detect_capabilities_mint_burn() {
+        // Bytecode containing mint and burn selectors
+        let bytecode = format!(
+            "608060405234{}00{}00{}",
+            capability_selectors::MINT,
+            capability_selectors::BURN,
+            "deadbeef"
+        );
+        let analyzer = BytecodeAnalyzer::new();
+        let caps = analyzer.detect_capabilities(&bytecode);
+        assert!(caps.has_mint);
+        assert!(caps.has_burn);
+        assert!(!caps.is_rebasing);
+    }
+
+    #[test]
+    fn test_detect_capabilities_one_rebase_selector_not_rebasing() {
+        // Only 1 rebase selector → not flagged as rebasing
+        let bytecode = format!("608060405234{}00deadbeef", capability_selectors::REBASE);
+        let analyzer = BytecodeAnalyzer::new();
+        let caps = analyzer.detect_capabilities(&bytecode);
+        assert!(!caps.is_rebasing);
+    }
+
+    #[test]
+    fn test_detect_capabilities_two_rebase_selectors_is_rebasing() {
+        let bytecode = format!(
+            "608060405234{}00{}00deadbeef",
+            capability_selectors::REBASE,
+            capability_selectors::SHARES_OF,
+        );
+        let analyzer = BytecodeAnalyzer::new();
+        let caps = analyzer.detect_capabilities(&bytecode);
+        assert!(caps.is_rebasing);
+    }
+
+    // ── Fee pattern detection ──────────────────────────────
+
+    #[test]
+    fn test_detect_fee_pattern() {
+        let analyzer = BytecodeAnalyzer::new();
+        // setFee(uint256) selector = 69fe0e2d
+        assert!(analyzer.detect_fee_pattern("6080604069fe0e2d0000"));
+        assert!(!analyzer.detect_fee_pattern("608060400000000000"));
+    }
+
+    // ── Full analyze ───────────────────────────────────────
+
+    #[test]
+    fn test_analyze_empty_bytecode() {
+        let analyzer = BytecodeAnalyzer::new();
+        let result = analyzer.analyze("0x");
+        assert_eq!(result.size_bytes, 0);
+        assert_eq!(result.complexity, BytecodeComplexity::Simple);
+        assert!(!result.is_proxy);
+    }
+
+    // ── Complexity boundary values ─────────────────────────
+
+    #[test]
+    fn test_complexity_boundary_5k() {
+        // Exactly 5*1024 = 5120 → Moderate (not Simple)
+        assert_eq!(
+            BytecodeAnalyzer::calculate_complexity(5 * 1024),
+            BytecodeComplexity::Moderate
+        );
+    }
+
+    #[test]
+    fn test_complexity_boundary_15k() {
+        // Exactly 15*1024 = 15360 → Complex (not Moderate)
+        assert_eq!(
+            BytecodeAnalyzer::calculate_complexity(15 * 1024),
+            BytecodeComplexity::Complex
+        );
+    }
 }

src/analyzers/evm/decoder.rs

@@ -155,6 +155,8 @@ impl AbiDecoder {
 mod tests {
     use super::*;
 
+    // ── uint8 ──────────────────────────────────────────────
+
     #[test]
     fn test_decode_uint8() {
         // Standard 32-byte padded response for decimals = 18
@@ -167,4 +169,92 @@ mod tests {
         let hex = "0x0000000000000000000000000000000000000000000000000000000000000006";
         assert_eq!(AbiDecoder::decode_uint8(hex).unwrap(), 6);
     }
+
+    #[test]
+    fn test_decode_uint8_zero() {
+        let hex = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        assert_eq!(AbiDecoder::decode_uint8(hex).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_decode_uint8_empty() {
+        assert_eq!(AbiDecoder::decode_uint8("0x").unwrap(), 0);
+        assert_eq!(AbiDecoder::decode_uint8("").unwrap(), 0);
+    }
+
+    // ── uint256 ────────────────────────────────────────────
+
+    #[test]
+    fn test_decode_uint256_zero() {
+        let hex = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        assert_eq!(AbiDecoder::decode_uint256(hex).unwrap(), "0");
+    }
+
+    #[test]
+    fn test_decode_uint256_small() {
+        // 1000000 in hex = 0xF4240
+        let hex = "0x00000000000000000000000000000000000000000000000000000000000f4240";
+        assert_eq!(AbiDecoder::decode_uint256(hex).unwrap(), "1000000");
+    }
+
+    #[test]
+    fn test_decode_uint256_u64_boundary() {
+        // u64::MAX = 18446744073709551615 = 0xFFFFFFFFFFFFFFFF (16 hex chars)
+        let hex = "0x000000000000000000000000000000000000000000000000ffffffffffffffff";
+        assert_eq!(
+            AbiDecoder::decode_uint256(hex).unwrap(),
+            "18446744073709551615"
+        );
+    }
+
+    #[test]
+    fn test_decode_uint256_u128_range() {
+        // A value that exceeds u64 but fits in u128
+        // 10^20 = 100000000000000000000 = 0x56BC75E2D63100000 (17 hex chars)
+        let hex = "0x0000000000000000000000000000000000000000000000056bc75e2d63100000";
+        assert_eq!(
+            AbiDecoder::decode_uint256(hex).unwrap(),
+            "100000000000000000000"
+        );
+    }
+
+    #[test]
+    fn test_decode_uint256_large_hex_to_decimal() {
+        // Exercises hex_to_decimal: value > 128 bits
+        // 2^160 = 1461501637330902918203684832716283019655932542976
+        // hex: 10000000000000000000000000000000000000000 (41 hex chars after trim)
+        let hex = "0x0000000000000000000000010000000000000000000000000000000000000000";
+        let result = AbiDecoder::decode_uint256(hex).unwrap();
+        assert_eq!(result, "1461501637330902918203684832716283019655932542976");
+    }
+
+    // ── string ─────────────────────────────────────────────
+
+    #[test]
+    fn test_decode_string_standard() {
+        // ABI-encoded "USDC": offset=0x20, length=4, data="USDC" padded
+        let hex = "0x\
+            0000000000000000000000000000000000000000000000000000000000000020\
+            0000000000000000000000000000000000000000000000000000000000000004\
+            5553444300000000000000000000000000000000000000000000000000000000";
+        assert_eq!(AbiDecoder::decode_string(hex).unwrap(), "USDC");
+    }
+
+    #[test]
+    fn test_decode_string_empty() {
+        // ABI-encoded empty string: offset=0x20, length=0
+        let hex = "0x\
+            0000000000000000000000000000000000000000000000000000000000000020\
+            0000000000000000000000000000000000000000000000000000000000000000";
+        assert_eq!(AbiDecoder::decode_string(hex).unwrap(), "");
+    }
+
+    #[test]
+    fn test_decode_string_short_fallback() {
+        // Non-standard short response — triggers extract_ascii fallback
+        // "MKR" in hex = 4d4b52
+        let hex = "4d4b5200000000000000000000000000000000000000000000000000000000";
+        let result = AbiDecoder::decode_string(hex).unwrap();
+        assert!(result.contains("MKR"));
+    }
 }

src/commands/list.rs

@@ -44,12 +44,7 @@ pub async fn run_list(
         discovery.curated_fallback(max_tokens)
     };
 
-    let source = if discover
-        && discovered
-            .first()
-            .and_then(|t| t.market_cap_rank)
-            .is_some()
-    {
+    let source = if discover && discovered.first().and_then(|t| t.market_cap_rank).is_some() {
         "CoinGecko"
     } else {
         "curated list"