Implement high-impact performance optimizations

- Add LZ4 message compression for 30-70% bandwidth reduction
- Implement adaptive battery optimization with power modes
- Optimize Bloom filter with bit-packed storage and SHA256 hashing
- Create WiFi Direct integration plan for future implementation
- Enable and update Bloom filter tests

bitchatTests/BloomFilterTests.swift

@@ -0,0 +1,101 @@
+//
+// BloomFilterTests.swift
+// bitchatTests
+//
+// This is free and unencumbered software released into the public domain.
+// For more information, see <https://unlicense.org>
+//
+
+import XCTest
+@testable import bitchat
+
+class BloomFilterTests: XCTestCase {
+    
+    func testBasicBloomFilter() {
+        var filter = OptimizedBloomFilter(expectedItems: 100, falsePositiveRate: 0.01)
+        
+        // Test insertion and lookup
+        let testStrings = ["message1", "message2", "message3", "test123"]
+        
+        for str in testStrings {
+            XCTAssertFalse(filter.contains(str))
+            filter.insert(str)
+            XCTAssertTrue(filter.contains(str))
+        }
+    }
+    
+    func testFalsePositiveRate() {
+        var filter = OptimizedBloomFilter(expectedItems: 100, falsePositiveRate: 0.01)
+        let itemCount = 100
+        
+        // Insert items
+        for i in 0..<itemCount {
+            filter.insert("item\(i)")
+        }
+        
+        // Check false positive rate
+        var falsePositives = 0
+        let testCount = 1000
+        
+        for i in itemCount..<(itemCount + testCount) {
+            if filter.contains("item\(i)") {
+                falsePositives += 1
+            }
+        }
+        
+        let falsePositiveRate = Double(falsePositives) / Double(testCount)
+        
+        // With optimized bloom filter targeting 1% false positive rate
+        XCTAssertLessThan(falsePositiveRate, 0.02) // Allow some margin
+    }
+    
+    func testReset() {
+        var filter = OptimizedBloomFilter(expectedItems: 100, falsePositiveRate: 0.01)
+        
+        // Insert some items
+        filter.insert("test1")
+        filter.insert("test2")
+        filter.insert("test3")
+        
+        XCTAssertTrue(filter.contains("test1"))
+        XCTAssertTrue(filter.contains("test2"))
+        XCTAssertTrue(filter.contains("test3"))
+        
+        // Reset
+        filter.reset()
+        
+        // Should no longer contain items
+        XCTAssertFalse(filter.contains("test1"))
+        XCTAssertFalse(filter.contains("test2"))
+        XCTAssertFalse(filter.contains("test3"))
+    }
+    
+    func testHashDistribution() {
+        var filter = OptimizedBloomFilter(expectedItems: 1000, falsePositiveRate: 0.01)
+        
+        // Insert many items
+        for i in 0..<500 {
+            filter.insert("message-\(i)")
+        }
+        
+        // Check false positive rate
+        let estimatedRate = filter.estimatedFalsePositiveRate
+        
+        // Should be well below target since we're at 50% capacity
+        XCTAssertLessThan(estimatedRate, 0.01)
+        
+        // Test memory efficiency
+        let memoryBytes = filter.memorySizeBytes
+        XCTAssertLessThan(memoryBytes, 2048) // Should be under 2KB for this size
+    }
+    
+    func testAdaptiveBloomFilter() {
+        // Test small network
+        let smallFilter = OptimizedBloomFilter.adaptive(for: 20)
+        XCTAssertLessThan(smallFilter.memorySizeBytes, 1024)
+        
+        // Test large network
+        let largeFilter = OptimizedBloomFilter.adaptive(for: 1000)
+        XCTAssertGreaterThan(largeFilter.memorySizeBytes, 2048)
+    }
+}