added data veridication

app.py

@@ -260,7 +260,7 @@ custom_css = """
 
 with gr.Blocks(title="📊 SN36 Validator States", css=custom_css) as demo:
     gr.Markdown("""
-    <h1 style="text-align: center; font-size: 3em; margin: 0.5em 0;">
+    <h1 style="text-align: center; font-size: 3em; margin: 0.5em 0; width: 100%; display: block;">
         📊 SN36 Validator States
     </h1>
     """, elem_id="title")

pyproject.toml

@@ -1,13 +0,0 @@
-[tool.ruff]
-# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
-select = ["E", "F"]
-ignore = ["E501"] # line too long (black is taking care of this)
-line-length = 119
-fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
-
-[tool.isort]
-profile = "black"
-line_length = 119
-
-[tool.black]
-line-length = 119

testing/fetch_bits.py

@@ -0,0 +1,135 @@
+import aiohttp
+import asyncio
+import numpy as np
+
+def generate_middle_column(steps: int) -> bytes:
+    """Generate the middle column of Rule 30 for n steps and return as bytes"""
+    print(f"Starting Rule 30 generation for {steps:,} steps...")
+    
+    # Use boolean array for faster operations
+    width = steps + 2  # Only need 1 cell padding on each side
+    state = np.zeros(width, dtype=bool)
+    state[width//2] = True
+    
+    # Pre-allocate array for ALL middle column bits
+    bits = np.zeros(steps, dtype=bool)
+    bits[0] = True  # First bit is always 1
+    
+    # Create views for faster access
+    left = state[:-2]
+    center = state[1:-1]
+    right = state[2:]
+    
+    # Progress tracking
+    update_every = max(1, steps // 1000)
+    
+    # Main loop - generate each step
+    for i in range(1, steps):
+        if i % update_every == 0:
+            print(f'\rGenerating... {(i/steps)*100:3.1f}% ({i:,}/{steps:,})', end='', flush=True)
+        
+        # Store middle bit at position i in our pre-allocated array
+        bits[i] = center[steps//2]  # This is where we save each middle column bit
+        
+        # Rule 30: next = left XOR (center OR right)
+        # Update center in-place for next iteration
+        np.logical_xor(left, np.logical_or(center, right), out=center)
+        
+        # Shift views for next iteration
+        left[1:] = left[:-1]
+        right[:-1] = right[1:]
+        left[0] = False
+        right[-1] = False
+    
+    print(f'\rGeneration complete: {steps:,} steps')
+    
+    # Convert all collected bits to bytes at once
+    byte_array = np.packbits(bits)  # This packs our middle column bits into bytes
+    return bytes(byte_array)
+
+async def fetch_validator_bits(ip: str = "65.109.145.104", port: int = 8091, num_bytes: int = 7) -> tuple[int, bytes, int]:
+    """Fetch step and most recent bytes from validator API"""
+    print("Starting API fetch...")
+    async with aiohttp.ClientSession() as session:
+        # Get step
+        step_url = f"http://{ip}:{port}/step"
+        async with session.get(step_url, timeout=5) as resp:
+            if resp.status != 200:
+                raise Exception(f"Failed to get step: {resp.status}")
+            step = await resp.json()
+            print(f"Got step: {step}")
+            if step <= 0:
+                raise Exception(f"Invalid step value: {step}")
+        
+        # Get only the most recent bytes
+        bits_url = f"http://{ip}:{port}/bits"
+        end_byte = (step + 7) // 8
+        start_byte = max(0, end_byte - num_bytes)
+        headers = {'Range': f'bytes={start_byte}-{end_byte-1}'}
+        print(f"Requesting bytes {start_byte}-{end_byte-1}...")
+        
+        async with session.get(bits_url, headers=headers, timeout=5) as resp:
+            if resp.status != 206:
+                raise Exception(f"Failed to get bits: {resp.status}")
+            
+            bytes_data = await resp.read()
+            if not bytes_data:
+                raise Exception("No data received")
+            
+            # Remove trailing zero bytes
+            while bytes_data and bytes_data[-1] == 0:
+                bytes_data = bytes_data[:-1]
+                
+            print(f"Got {len(bytes_data)} non-zero bytes")
+            return step, bytes_data, start_byte
+
+async def main():
+    try:
+        # Get most recent bytes from API
+        step, api_bytes, start_pos = await fetch_validator_bits(num_bytes=7)
+        print("\nAPI bytes details:")
+        print(f"Step: {step}")
+        print(f"Starting from byte position: {start_pos}")
+        
+        # Skip the last byte from API for comparison
+        api_bytes = api_bytes[:-1]
+        
+        # Generate matching bytes
+        print("\nGenerating Rule 30 bytes...")
+        test_bytes = generate_middle_column(step)
+        
+        # Calculate positions
+        total_bytes = (step + 7) // 8
+        # Get bytes from the same positions as API bytes
+        test_bytes = test_bytes[start_pos:start_pos + len(api_bytes)]
+        
+        # Show the bytes we're comparing
+        print("\nBytes being compared:")
+        print("API bytes:")
+        for i, b in enumerate(api_bytes):
+            abs_pos = start_pos + i
+            print(f"Position {abs_pos}: {hex(b)} (binary: {format(b, '08b')})")
+            
+        print("\nGenerated bytes:")
+        for i, b in enumerate(test_bytes):
+            abs_pos = start_pos + i
+            print(f"Position {abs_pos}: {hex(b)} (binary: {format(b, '08b')})")
+        
+        # Compare bytes
+        if api_bytes == test_bytes:
+            print("\n✅ Bytes match")
+        else:
+            print("\n❌ Bytes differ")
+            for i, (a, b) in enumerate(zip(api_bytes, test_bytes)):
+                abs_pos = start_pos + i
+                if a != b:
+                    print(f"\nFirst difference at position {abs_pos}:")
+                    print(f"API:       {hex(a)} (binary: {format(a, '08b')})")
+                    print(f"Generated: {hex(b)} (binary: {format(b, '08b')})")
+                    break
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

testing/validatorbyte.py

@@ -0,0 +1,34 @@
+import asyncio
+import aiohttp
+
+async def get_nth_byte(n: int, ip: str = "65.109.145.104", port: int = 8091) -> bytes:
+    """Fetch the nth byte from validator API"""
+    print(f"Fetching byte at position {n}")
+    
+    async with aiohttp.ClientSession() as session:
+        # Get just the single byte we want
+        bits_url = f"http://{ip}:{port}/bits"
+        headers = {'Range': f'bytes={n}-{n}'}
+        
+        async with session.get(bits_url, headers=headers, timeout=5) as resp:
+            if resp.status != 206:
+                raise Exception(f"Failed to get byte: {resp.status}")
+            
+            byte_data = await resp.read()
+            if not byte_data:
+                raise Exception("No data received")
+            
+            print(f"Got byte: {hex(byte_data[0])} (binary: {format(byte_data[0], '08b')})")
+            return byte_data
+
+async def main():
+    try:
+        # Get byte at position n
+        n = 167371  # Change this to get different bytes
+        byte_data = await get_nth_byte(n)
+        
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

validate_rule30.py

@@ -0,0 +1,69 @@
+import argparse
+from typing import Optional
+
+def get_next_bit(left: str, center: str, right: str) -> str:
+    """Rule 30 implementation:
+    111 -> 0
+    110 -> 0
+    101 -> 0
+    100 -> 1
+    011 -> 1
+    010 -> 1
+    001 -> 1
+    000 -> 0
+    """
+    pattern = left + center + right
+    rule30_map = {
+        "111": "0", "110": "0", "101": "0", "100": "1",
+        "011": "1", "010": "1", "001": "1", "000": "0"
+    }
+    return rule30_map[pattern]
+
+def validate_sequence(bits: str) -> tuple[bool, Optional[int]]:
+    """Validate if a sequence follows Rule 30.
+    Returns (is_valid, first_error_position)
+    """
+    if not all(bit in '01' for bit in bits):
+        return False, 0
+    
+    # Pad with zeros for edge cases
+    padded = '0' + bits + '0'
+    
+    for i in range(1, len(bits) + 1):
+        expected = get_next_bit(
+            padded[i-1], 
+            padded[i], 
+            padded[i+1]
+        )
+        if i < len(bits) and bits[i] != expected:
+            return False, i
+            
+    return True, None
+
+def main():
+    parser = argparse.ArgumentParser(description='Validate a binary sequence against Rule 30')
+    parser.add_argument('file', help='Path to file containing binary sequence')
+    args = parser.parse_args()
+    
+    try:
+        with open(args.file, 'r') as f:
+            bits = f.read().strip()
+            
+        is_valid, error_pos = validate_sequence(bits)
+        
+        if is_valid:
+            print("✅ Sequence follows Rule 30")
+            return 0
+        else:
+            print(f"❌ Sequence violates Rule 30 at position {error_pos}")
+            return 1
+            
+    except FileNotFoundError:
+        print(f"Error: File {args.file} not found")
+        return 2
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return 3
+
+if __name__ == "__main__":
+    exit(main())