mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
406 lines
15 KiB
Python
406 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
# ==============================================================================
|
|
# COPYRIGHT NO ONE EVERYWHERE LLC (WYOMING HOLDING COMPANY)
|
|
# PROJECT: SOVEREIGN STACK
|
|
# This artifact is entirely proprietary and cryptographically proven.
|
|
# Open-Source usage requires explicit permission from Brandon Scott Schneider.
|
|
# ==============================================================================
|
|
"""
|
|
Jupiter Boxes Transport Layer — φ-locked MIMO encoding for Omnitoken packets
|
|
|
|
Integrates soliton_factory.py Jupiter encoding with mimo_transport_router.py
|
|
to enable 14 independent datasets per carrier surface with zero cross-interference.
|
|
|
|
Protocol:
|
|
1. Payload → split into 14 chunks (or 7 in SEISMIC phase)
|
|
2. Each chunk → φ-locked mode amplitude
|
|
3. Modes → pack into SolitonBox format
|
|
4. Boxes + phase metadata → transport via I2P/Omnitoken
|
|
5. Receiver: phase-lock to target mode index → extract dataset
|
|
|
|
No cipher. No key. Only knowing which mode to listen for.
|
|
"""
|
|
|
|
import json
|
|
import math
|
|
import hashlib
|
|
import base64
|
|
from typing import Dict, List, Optional, Tuple
|
|
from dataclasses import dataclass, field
|
|
from enum import Enum
|
|
import sys
|
|
import os
|
|
|
|
sys.path.insert(0, os.path.dirname(__file__))
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'scripts'))
|
|
|
|
try:
|
|
from soliton_factory import (
|
|
jupiter_encode, jupiter_decode, SolitonBox, pack_label, unpack_label,
|
|
_PHASE_GROUNDED, _PHASE_SEISMIC, _PHASE_FLAME,
|
|
_PHI, _J_MODES, _J_BAND
|
|
)
|
|
_HAS_SOLITON = True
|
|
except ImportError:
|
|
_HAS_SOLITON = False
|
|
|
|
|
|
class JupiterPhase(Enum):
|
|
"""Phase classification for Jupiter encoding.
|
|
|
|
These describe the state of the signal's underlying manifold:
|
|
GROUNDED = crystallized, SEISMIC = shifting, FLAME = burning/reforming.
|
|
"""
|
|
GROUNDED = "PHASE_GROUNDED" # 14 boxes, full multiplexing
|
|
SEISMIC = "PHASE_SEISMIC" # 7 boxes, partial encoding
|
|
FLAME = "PHASE_FLAME" # No Jupiter encoding
|
|
|
|
|
|
@dataclass
|
|
class JupiterTransportPacket:
|
|
"""Encoded Jupiter-layer MIMO packet"""
|
|
manifest_id: str # SHA256 of original payload
|
|
payload_hash: str # SHA256 of split chunks
|
|
phase: str # GROUNDED, SEISMIC, or FLAME
|
|
n_boxes: int # 14, 7, or 0
|
|
n_active_modes: int # which modes were encoded
|
|
boxes_json: str # Serialized SolitonBox list (phase geometry)
|
|
metadata: Dict = None # Phase metrics, band_amps, etc.
|
|
# Separable data field — orthogonal to the geometry stream.
|
|
# Peels off cleanly when transport splits into parallel channels.
|
|
chunks_b64: Optional[str] = None
|
|
|
|
def to_json(self) -> str:
|
|
return json.dumps({
|
|
'manifest_id': self.manifest_id,
|
|
'payload_hash': self.payload_hash,
|
|
'phase': self.phase,
|
|
'n_boxes': self.n_boxes,
|
|
'n_active_modes': self.n_active_modes,
|
|
'boxes': self.boxes_json,
|
|
'metadata': self.metadata or {},
|
|
'chunks_b64': self.chunks_b64,
|
|
})
|
|
|
|
@staticmethod
|
|
def from_json(data: str) -> 'JupiterTransportPacket':
|
|
obj = json.loads(data)
|
|
return JupiterTransportPacket(
|
|
manifest_id=obj['manifest_id'],
|
|
payload_hash=obj['payload_hash'],
|
|
phase=obj['phase'],
|
|
n_boxes=obj['n_boxes'],
|
|
n_active_modes=obj['n_active_modes'],
|
|
boxes_json=obj['boxes'],
|
|
metadata=obj.get('metadata'),
|
|
chunks_b64=obj.get('chunks_b64'),
|
|
)
|
|
|
|
|
|
class JupiterBoxesTransport:
|
|
"""
|
|
φ-locked MIMO multiplexing for Omnitoken transport.
|
|
|
|
Wraps soliton_factory jupiter_encode/decode and provides:
|
|
- Payload splitting into independent modes
|
|
- Phase classification based on entropy
|
|
- Serialization to JSON for transport
|
|
- Mode extraction at receiver side
|
|
"""
|
|
|
|
def __init__(self):
|
|
if not _HAS_SOLITON:
|
|
raise ImportError("soliton_factory.py required for Jupiter encoding")
|
|
|
|
self.phi = _PHI
|
|
self.n_modes = _J_MODES # 14
|
|
self.band_marker = _J_BAND # 0xFE
|
|
|
|
def split_payload(self, payload: bytes, phase: str = _PHASE_GROUNDED) -> List[bytes]:
|
|
"""
|
|
Split payload into 14 (or 7) independent chunks.
|
|
|
|
Each chunk can be extracted independently at receiver if tuned to that mode index.
|
|
"""
|
|
n_active = self.n_modes if phase == _PHASE_GROUNDED else (7 if phase == _PHASE_SEISMIC else 1)
|
|
|
|
chunk_size = len(payload) // n_active
|
|
remainder = len(payload) % n_active
|
|
|
|
chunks = []
|
|
pos = 0
|
|
|
|
for i in range(n_active):
|
|
size = chunk_size + (1 if i < remainder else 0)
|
|
chunks.append(payload[pos:pos+size])
|
|
pos += size
|
|
|
|
# Pad to exactly n_active chunks
|
|
while len(chunks) < n_active:
|
|
chunks.append(b'')
|
|
|
|
return chunks[:n_active]
|
|
|
|
def encode_payload(
|
|
self,
|
|
payload: bytes,
|
|
band_amplitudes: Optional[List[float]] = None,
|
|
) -> JupiterTransportPacket:
|
|
"""
|
|
Encode payload using Jupiter φ-locked MIMO.
|
|
|
|
Args:
|
|
payload: Data to encode
|
|
band_amplitudes: Optional spectral data for better phase classification
|
|
|
|
Returns:
|
|
JupiterTransportPacket with encoded boxes and metadata
|
|
"""
|
|
manifest_id = hashlib.sha256(payload).hexdigest()
|
|
|
|
# Estimate residual entropy
|
|
residual_entropy = len(payload) * 8.0 # bits
|
|
|
|
# Use provided band_amps or synthesize from payload distribution
|
|
if band_amplitudes is None:
|
|
# Simple heuristic: byte value distribution
|
|
byte_counts = {}
|
|
for b in payload:
|
|
byte_counts[b] = byte_counts.get(b, 0) + 1
|
|
band_amplitudes = [
|
|
byte_counts.get(i, 0) / max(len(payload), 1)
|
|
for i in range(min(14, max(256 // 18, 8))) # ~14 bands
|
|
]
|
|
|
|
# Jupiter encoding (via soliton_factory)
|
|
boxes, phase = jupiter_encode(residual_entropy, band_amplitudes)
|
|
|
|
# Split payload into chunks
|
|
chunks = self.split_payload(payload, phase)
|
|
payload_hash = hashlib.sha256(b''.join(chunks)).hexdigest()
|
|
|
|
# Separable data field: chunks travel alongside the geometry, not inside it
|
|
chunks_b64 = json.dumps([base64.b64encode(c).decode() for c in chunks])
|
|
|
|
# Serialize boxes to JSON (SolitonBox as dicts)
|
|
boxes_data = [
|
|
{
|
|
'label': box.label,
|
|
'value_bits': box.value_bits,
|
|
'address': box.address,
|
|
}
|
|
for box in boxes
|
|
]
|
|
boxes_json = json.dumps(boxes_data)
|
|
|
|
n_active = len(chunks)
|
|
|
|
return JupiterTransportPacket(
|
|
manifest_id=manifest_id,
|
|
payload_hash=payload_hash,
|
|
phase=phase,
|
|
n_boxes=len(boxes),
|
|
n_active_modes=n_active,
|
|
boxes_json=boxes_json,
|
|
metadata={
|
|
'residual_entropy': residual_entropy,
|
|
'band_count': len(band_amplitudes),
|
|
'phase_marker': _J_BAND,
|
|
'phi_scale': self.phi,
|
|
'payload_size': len(payload),
|
|
'chunk_sizes': [len(c) for c in chunks],
|
|
},
|
|
chunks_b64=chunks_b64,
|
|
)
|
|
|
|
def decode_payload(self, packet: JupiterTransportPacket) -> Optional[bytes]:
|
|
"""
|
|
Decode Jupiter-encoded packet.
|
|
|
|
Two-step: verify phase geometry first (lock-in test), then reassemble
|
|
chunks from the separable data field. If the manifold says geometry is
|
|
wrong, reject before touching the data.
|
|
"""
|
|
try:
|
|
# Step 1: reconstruct boxes and run the overlay (lock-in test)
|
|
boxes_data = json.loads(packet.boxes_json)
|
|
boxes = [SolitonBox(bd['label'], bd['value_bits']) for bd in boxes_data]
|
|
residual, phase = jupiter_decode(boxes)
|
|
|
|
if phase == _PHASE_FLAME:
|
|
print(f"[JupiterTransport] Phase FLAME — manifold incoherent, rejecting")
|
|
return None
|
|
|
|
expected_bits = packet.metadata.get('residual_entropy', 0)
|
|
if expected_bits > 0:
|
|
err = abs(residual - expected_bits) / expected_bits
|
|
if err > 0.01: # 1% tolerance — f16 floor is ~0.098%, roundtrip error ~0.032%
|
|
print(f"[JupiterTransport] Residual mismatch: {residual:.1f} vs {expected_bits:.1f} ({err:.1%})")
|
|
return None
|
|
|
|
# Step 2: reassemble from separable chunk field
|
|
if not packet.chunks_b64:
|
|
print(f"[JupiterTransport] No chunk data in packet")
|
|
return None
|
|
|
|
chunk_list = json.loads(packet.chunks_b64)
|
|
payload = b''.join(base64.b64decode(c) for c in chunk_list)
|
|
|
|
# Step 3: integrity check
|
|
if hashlib.sha256(payload).hexdigest() != packet.manifest_id:
|
|
print(f"[JupiterTransport] Payload hash mismatch")
|
|
return None
|
|
|
|
return payload
|
|
|
|
except Exception as e:
|
|
print(f"[JupiterTransport] Decode error: {e}")
|
|
return None
|
|
|
|
def extract_mode(
|
|
self,
|
|
packet: JupiterTransportPacket,
|
|
mode_index: int,
|
|
) -> Optional[bytes]:
|
|
"""
|
|
Extract single mode dataset from Jupiter packet (receiver-side phase-lock).
|
|
|
|
Pre-DSP lock-in approach: overlay all 14 channels, check φ-ratio coheres,
|
|
then return the chunk for the requested mode. The coherence test (jupiter_decode)
|
|
is the tuner — it confirms the receiver is phase-locked before handing over data.
|
|
"""
|
|
try:
|
|
if mode_index >= packet.n_active_modes:
|
|
return None
|
|
|
|
# Tune: overlay all channels and verify φ-ratio emerges
|
|
boxes_data = json.loads(packet.boxes_json)
|
|
boxes = [SolitonBox(bd['label'], bd['value_bits']) for bd in boxes_data]
|
|
_, phase = jupiter_decode(boxes)
|
|
|
|
if phase == _PHASE_FLAME:
|
|
return None # No lock — manifold incoherent
|
|
|
|
# Phase-locked: return the chunk for this mode from the separable field
|
|
if not packet.chunks_b64:
|
|
return None
|
|
|
|
chunk_list = json.loads(packet.chunks_b64)
|
|
if mode_index < len(chunk_list):
|
|
return base64.b64decode(chunk_list[mode_index])
|
|
|
|
return None
|
|
|
|
except Exception as e:
|
|
print(f"[JupiterTransport] Mode extraction error: {e}")
|
|
return None
|
|
|
|
def get_status(self) -> Dict:
|
|
"""Return transport status"""
|
|
return {
|
|
'phi_locking': self.phi,
|
|
'total_modes': self.n_modes,
|
|
'band_marker': hex(self.band_marker),
|
|
'phases_supported': [JupiterPhase.GROUNDED.value, JupiterPhase.SEISMIC.value, JupiterPhase.FLAME.value],
|
|
}
|
|
|
|
|
|
# ───────────────────────────────────────────────────────────────────────────
|
|
# Integration with MIMO Router
|
|
# ───────────────────────────────────────────────────────────────────────────
|
|
|
|
try:
|
|
from mimo_transport_router import get_router
|
|
_HAS_MIMO_ROUTER = True
|
|
except ImportError:
|
|
_HAS_MIMO_ROUTER = False
|
|
|
|
|
|
def route_with_jupiter(payload: bytes, destination_hint: str = None) -> Dict:
|
|
"""
|
|
Route payload via MIMO+Jupiter: I2P manifests + φ-locked MIMO encoding.
|
|
|
|
Pipeline:
|
|
1. MIMO Router: payload → I2P manifest (deterministic chunks)
|
|
2. Jupiter Layer: manifest → φ-locked mode encoding
|
|
3. Transport: boxes → Omnitoken/I2P/Tailscale
|
|
"""
|
|
if not _HAS_MIMO_ROUTER:
|
|
return {'error': 'MIMO router not available'}
|
|
|
|
router = get_router()
|
|
mime_routing = router.route_payload(payload, destination_hint)
|
|
|
|
# Apply Jupiter encoding
|
|
jupiter = JupiterBoxesTransport()
|
|
jupiter_packet = jupiter.encode_payload(payload)
|
|
|
|
result = dict(mime_routing)
|
|
result['jupiter_layer'] = {
|
|
'phase': jupiter_packet.phase,
|
|
'n_boxes': jupiter_packet.n_boxes,
|
|
'n_active_modes': jupiter_packet.n_active_modes,
|
|
'packet_id': jupiter_packet.manifest_id[:16],
|
|
}
|
|
|
|
# Murphy-law hardening: if phase enters FLAME, avoid relying on Jupiter-only path.
|
|
if jupiter_packet.phase == JupiterPhase.FLAME.value:
|
|
result['jupiter_layer']['flame_mode_hardening'] = True
|
|
result['jupiter_layer']['jupiter_mux_reliable'] = False
|
|
result['jupiter_layer']['fallback_shell'] = 'adaptive_manifest'
|
|
result['routing_metadata'] = result.get('routing_metadata', {})
|
|
result['routing_metadata']['jupiter_phase_risk'] = 'flame'
|
|
result['routing_metadata']['jupiter_failover'] = 'force_non_jupiter_shell'
|
|
else:
|
|
result['jupiter_layer']['flame_mode_hardening'] = False
|
|
result['jupiter_layer']['jupiter_mux_reliable'] = True
|
|
|
|
return result
|
|
|
|
|
|
# ───────────────────────────────────────────────────────────────────────────
|
|
# CLI Test
|
|
# ───────────────────────────────────────────────────────────────────────────
|
|
|
|
def main():
|
|
if not _HAS_SOLITON:
|
|
print("[!] soliton_factory not available")
|
|
return
|
|
|
|
jupiter = JupiterBoxesTransport()
|
|
|
|
print("[Jupiter Boxes Transport] Testing φ-locked MIMO encoding...\n")
|
|
|
|
# Test payloads
|
|
test_cases = [
|
|
(b"Hello Jupiter World! " * 100, "Structured English text"),
|
|
(b"\x00\x01\x02\x03" * 250, "Low entropy"),
|
|
(bytes(range(256)) * 10, "Full byte range"),
|
|
]
|
|
|
|
for payload, label in test_cases:
|
|
print(f"[Test: {label}]")
|
|
print(f" Payload size: {len(payload)} bytes")
|
|
|
|
# Encode
|
|
packet = jupiter.encode_payload(payload)
|
|
print(f" Phase: {packet.phase}")
|
|
print(f" Boxes: {packet.n_boxes}")
|
|
print(f" Active modes: {packet.n_active_modes}")
|
|
print(f" Manifest ID: {packet.manifest_id[:16]}...")
|
|
|
|
# Decode
|
|
recovered = jupiter.decode_payload(packet)
|
|
if recovered:
|
|
match = "✓ MATCH" if recovered == payload else "✗ MISMATCH"
|
|
print(f" Recovery: {match} ({len(recovered)} bytes)")
|
|
else:
|
|
print(f" Recovery: ✗ FAILED")
|
|
|
|
print()
|
|
|
|
print(f"\n[Status]\n{json.dumps(jupiter.get_status(), indent=2)}")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|