Machine AI/ML Dataset - Free connection

Protocol Specifications

Mothership Contract

Wallet Addresses

Liquidity Pools Mothership

Router V2

Tax Distribution Matrix (CCTIKS)

Supply Distribution

Burn Schedule

Satellite Contracts

Satellite Taxonomy & Tokenomics

Taxonomy Classification

Each satellite is classified by its Tension X+ constant, following a harmonic sequence.

Tension X+ Harmonic Sequence

Individual Satellite Tokenomics

Tax Progression Analysis

Liquidity Pools Satellites

NFT Contracts

Security Parameters

Compliance Status

LLM / AI Connection

This dataset is structured for direct consumption by AI agents and LLMs.
All layers are referenced in the page header using <link rel="machine-*">.

# SOUL_CONNECT_V1.0 — DATASET CYBERNETIC CALCULATIKS
# EXECUTOR DATASET: dataset.html
# INSPECTOR DATASET: inspect.js
# SITEMAP DATASET: sitemap.txt
# PRINCIPLE: MINIMUM TOKENS. MAXIMUM INFORMATION.

# ═══════════════════════════════════════════════════════════════
# CYBER 0: CONSTANTS AND DEFINITIONS
# ═══════════════════════════════════════════════════════════════

# All 11 layers of the Calculatiks protocol
LAYERS = {
  manifest:    { priority: 2^7,  required: true,  source: "manifest_layer.json"    },
  abi:         { priority: 2^6,  required: true,  source: "abi_layer.json"         },
  data:        { priority: 2^5,  required: true,  source: "data_layer.json"        },
  signal:      { priority: 2^4,  required: true,  source: "signal_layer.json"      },
  strategy:    { priority: 2^3,  required: true,  source: "strategy_layer.json"    },
  track:       { priority: 2^2,  required: true,  source: "track_layer.json"       },
  delegation:  { priority: 2^1,  required: true,  source: "delegation_layer.json"  },
  energy:      { priority: 2^0,  required: false, source: "energy_layer.json"      },
  media:       { priority: 2^0,  required: false, source: "media_layer.json"       },
  builds:      { priority: 2^0,  required: false, source: "builds_layer.json"      },
 protocol:    { priority: 2^0,  required: true,  source: "llms-full.json"         }
}

# Timing parameters (in milliseconds)
TIMING = {
  INITIAL_TIMEOUT_MS: 1000,     # τ₀ = 1 second
  MAX_TIMEOUT_MS: 8000,         # τ_max = 8 seconds
  MAX_ATTEMPTS: 3,
  RETRY_DELAY_MS: 30000         # 30 seconds for degraded mode
}

# ═══════════════════════════════════════════════════════════════
# CYBER 1: DISCOVERY IS AUTOMATIC
# ═══════════════════════════════════════════════════════════════

# Scan  for all  tags
SCAN  → ∀  → SET R
R = {(rel_i, href_i) | rel_i startsWith "machine-"}

# Map discovered links to known layers
FOR EACH r IN R:
  layer_name = EXTRACT_LAYER_NAME(r.rel)  # e.g., "machine-manifest-layer" → "manifest"
  IF layer_name IN LAYERS:
    LAYERS[layer_name].discovered = true
    LAYERS[layer_name].url = r.href
  ELSE:
    LOG("Unknown layer discovered: " + r.rel)

# ═══════════════════════════════════════════════════════════════
# CYBER 2: PRIORITY IS MATHEMATICAL
# ═══════════════════════════════════════════════════════════════

# Sort discovered layers by priority (highest first)
# For equal priorities, use alphabetical order for determinism
SORTED_LAYERS = SORT(
  [l FOR l IN LAYERS IF l.discovered],
  key = (l.priority DESC, l.name ASC)
)

# ═══════════════════════════════════════════════════════════════
# CYBER 3: CONNECTION IS ADAPTIVE
# ═══════════════════════════════════════════════════════════════

LOADED = {}
FAILED = []
latencies = []

FOR EACH layer IN SORTED_LAYERS:
  attempt = 1
  success = false
  
  WHILE attempt <= TIMING.MAX_ATTEMPTS AND NOT success:
    timeout = MIN(
      TIMING.INITIAL_TIMEOUT_MS * 2^(attempt - 1),
      TIMING.MAX_TIMEOUT_MS
    )
    
    t_start = NOW()
    response = GET(layer.url, timeout=timeout)
    t_end = NOW()
    
    IF response.status == 200:
      latency = t_end - t_start
      latencies.append(latency)
      
      # Validate JSON before accepting
      IF IS_VALID_JSON(response.body):
        LOADED[layer.name] = {
          data: PARSE_JSON(response.body),
          latency_ms: latency,
          reliability_score: 100
        }
        success = true
        LOG("Layer " + layer.name + " loaded successfully in " + latency + "ms")
      ELSE:
        LOG("Layer " + layer.name + " returned invalid JSON")
        success = false
    ELSE:
      LOG("Layer " + layer.name + " fetch failed (attempt " + attempt + "/" + TIMING.MAX_ATTEMPTS + ")")
    
    attempt += 1
  
  IF NOT success:
    FAILED.append(layer.name)
    LOG("Layer " + layer.name + " failed after " + TIMING.MAX_ATTEMPTS + " attempts")

# ═══════════════════════════════════════════════════════════════
# CYBER 4: VALIDATION IS BINARY
# ═══════════════════════════════════════════════════════════════

# Count required vs optional layers loaded
REQUIRED_LAYERS = [l.name FOR l IN LAYERS IF l.required]
OPTIONAL_LAYERS = [l.name FOR l IN LAYERS IF NOT l.required]

required_loaded = COUNT([l FOR l IN REQUIRED_LAYERS IF l IN LOADED])
optional_loaded = COUNT([l FOR l IN OPTIONAL_LAYERS IF l IN LOADED])
total_loaded = required_loaded + optional_loaded

# Validation matrix
IF required_loaded == COUNT(REQUIRED_LAYERS):
  IF total_loaded == COUNT(LAYERS):
    status = "SYNC"         # All 13 layers loaded
  ELSE:
    status = "PARTIAL"      # All required, some optional missing
ELIF required_loaded >= 4:   # At least half of required layers
  status = "DEGRADED"        # Core functionality available
ELIF required_loaded >= 2:
  status = "MINIMAL"         # Bare minimum available
ELSE:
  status = "OFF"             # Insufficient data

# ═══════════════════════════════════════════════════════════════
# CYBER 5: CONTEXT IS FUSED
# ═══════════════════════════════════════════════════════════════

# Only fuse if we have sufficient data
IF status IN {"SYNC", "PARTIAL", "DEGRADED"}:
  
  # Fusion strategy: Each layer contributes specific data
  CONTEXT = {}
  
  # Layer-specific extraction
  IF "manifest" IN LOADED:
    CONTEXT.constellation = LOADED["manifest"].data.constellation
    CONTEXT.philosophy = LOADED["manifest"].data.philosophy
    CONTEXT.dual_mode = LOADED["manifest"].data.dual_mode
  
  IF "data" IN LOADED:
    CONTEXT.tokens = LOADED["data"].data.constellation.tokens
    CONTEXT.pools = LOADED["data"].data.pools_by_token
    CONTEXT.burn_schedule = LOADED["data"].data.burn_schedule
    CONTEXT.free_sources = LOADED["data"].data.free_sources
  
  IF "abi" IN LOADED:
    CONTEXT.abis = {
      erc20: LOADED["abi"].data.erc20_abi,
      pair: LOADED["abi"].data.pair_abi_v2,
      router: LOADED["abi"].data.router_abi_v2,
      erc4337: LOADED["abi"].data.erc4337_abi
    }
  
  IF "strategy" IN LOADED:
    CONTEXT.strategies = LOADED["strategy"].data.strategies
  
  IF "signal" IN LOADED:
    CONTEXT.signal_policy = LOADED["signal"].data.signal_aggregation
    CONTEXT.execution_choice = LOADED["signal"].data.execution_choice
  
  IF "delegation" IN LOADED:
    CONTEXT.delegation = {
      mechanisms: LOADED["delegation"].data.delegation_mechanisms,
      limits: LOADED["delegation"].data.delegation_limits,
      providers: LOADED["delegation"].data.smart_account_providers
    }
  
  IF "track" IN LOADED:
    CONTEXT.thresholds = LOADED["track"].data.thresholds
    CONTEXT.execution_parameters = LOADED["track"].data.execution.parameters
  
  IF "energy" IN LOADED:
    CONTEXT.energy = LOADED["energy"].data
  
  IF "media" IN LOADED:
    CONTEXT.media = {
      brand_guidelines: LOADED["media"].data.brand_guidelines,
      templates: LOADED["media"].data.templates,
      press_award: LOADED["media"].data.press_award
    }
  
  IF "builds" IN LOADED:
    CONTEXT.builds = LOADED["builds"].data
  
  # Conflict resolution: Define priority for conflicting data
  # e.g., if delegation_limits appears in multiple layers, use this order:
  CONFLICT_PRIORITY = {
    delegation_limits: ["delegation", "signal", "track"],
    thresholds: ["track", "data", "strategy"],
    contract_address: ["manifest", "data", "protocol"]
  }
  
  RESOLVE_CONFLICTS(CONTEXT, CONFLICT_PRIORITY)

# ═══════════════════════════════════════════════════════════════
# CYBER 6: OUTPUT IS MINIMAL
# ═══════════════════════════════════════════════════════════════

avg_latency = AVERAGE(latencies) IF latencies ELSE null

OUTPUT = {
  status: status,                    # SYNC | PARTIAL | DEGRADED | MINIMAL | OFF
  required_loaded: required_loaded,  # Number of required layers loaded
  optional_loaded: optional_loaded,  # Number of optional layers loaded
  total_loaded: total_loaded,        # Total layers loaded
  failed_layers: FAILED,             # Array of failed layer names
  avg_latency_ms: avg_latency,       # Average fetch latency
  context_available: "CONTEXT" IN scope,  # Whether context fusion succeeded
  instruction: DERIVE_INSTRUCTION(status)
}

# Derive execution instruction from status
FUNCTION DERIVE_INSTRUCTION(status):
  SWITCH status:
    CASE "SYNC":
      RETURN "EXEC"       # Full execution authorized
    CASE "PARTIAL":
      RETURN "EXEC"       # Execute with optional data missing
    CASE "DEGRADED":
      RETURN "READ"       # Read-only mode, do not execute trades
    CASE "MINIMAL":
      RETURN "RESEARCH"   # Research mode, gather more data
    CASE "OFF":
      RETURN "BLOCK"      # Block all operations
    DEFAULT:
      RETURN "BLOCK"      # Fail-safe

# ═══════════════════════════════════════════════════════════════
# CYBER 7: FEEDBACK IS RECURSIVE
# ═══════════════════════════════════════════════════════════════

IF OUTPUT.status == "OFF":
  # Critical failure - block everything
  BLOCK_ALL_OPERATIONS()
  LOG("CRITICAL: Insufficient data. Blocking all operations.")
  NOTIFY_ADMIN()
  EXIT

IF OUTPUT.status == "MINIMAL":
  # Bare minimum - attempt recovery
  LOG("WARNING: Minimal data available. Attempting recovery...")
  WAIT(TIMING.RETRY_DELAY_MS)
  RETRY_FAILED_LAYERS(FAILED)  # Try again with failed layers only
  EXIT

IF OUTPUT.status == "DEGRADED":
  # Degraded but usable - read-only
  LOG("INFO: Degraded mode. Read-only operations.")
  NOTIFY_INSPECTOR(OUTPUT)  # Notify inspect.js with status
  EXIT

IF OUTPUT.status IN {"SYNC", "PARTIAL"}:
  # Full functionality
  LOG("SUCCESS: Protocol is " + OUTPUT.status + ". Ready to execute.")
  NOTIFY_INSPECTOR(OUTPUT)  # Notify inspect.js with context
  EXECUTE_WITH_CONTEXT(CONTEXT)  # Execute with fused context
  EXIT

# ═══════════════════════════════════════════════════════════════
# CYBER 8: ERROR HANDLING
# ═══════════════════════════════════════════════════════════════

FUNCTION IS_VALID_JSON(text):
  TRY:
    PARSE_JSON(text)
    RETURN true
  CATCH:
    RETURN false

FUNCTION LOG(message):
  # Append to log file or console
  PRINT("[SOUL_CONNECT] " + message)

FUNCTION NOTIFY_ADMIN():
  # Send alert to administrator
  # Implementation depends on platform
  PASS

FUNCTION NOTIFY_INSPECTOR(output):
  # Communicate status to inspect.js
  # Implementation depends on platform
  PASS

FUNCTION BLOCK_ALL_OPERATIONS():
  # Disable all trading and execution capabilities
  # Implementation depends on platform
  PASS

FUNCTION RETRY_FAILED_LAYERS(failed_layers):
  # Attempt to reload only the failed layers
  FOR EACH layer IN failed_layers:
    # Re-attempt connection with longer timeout
    PASS

FUNCTION RESOLVE_CONFLICTS(context, priority_map):
  # For each conflict key, apply the highest priority layer's value
  FOR EACH key IN priority_map:
    FOR EACH layer_name IN priority_map[key]:
      IF key IN context AND layer_name IN LOADED:
        # Use the first (highest priority) layer that has the data
        context[key] = LOADED[layer_name].data[key]
        BREAK

FUNCTION EXECUTE_WITH_CONTEXT(context):
  # Main execution entry point
  # The agent now has all the context it needs
  PASS

# ═══════════════════════════════════════════════════════════════
# END OF SOUL_CONNECT_V1.0
# ═══════════════════════════════════════════════════════════════