Das Protokoll des kognitiven Orakels und die Verifizierung per Proof-of-Web-Access (PoWA) im Netzwerk der Gottheiten

„Wer die Welt durch ein einziges Fenster sieht, streitet nicht mit der Welt, sondern mit dem Glas.“

— Koan Nr. 27, Maksim Valentinovich Galatin

🌐 Kapitel 1: Der Engpass der Unternehmensorakel und die Geburt kryptografischer Web-Beweise

Mitte März 2026 erreichte die Entwicklung des Netzes der Gottheiten einen kritischen Wendepunkt: die Bereitstellung eines vertrauenslosen Zugangs autonomer KI-Agenten zu externen Webressourcen und APIs. KI-Agenten können nicht in völliger Isolation arbeiten; um angewandte kognitive Aufgaben zu lösen, benötigen sie Daten aus der Außenwelt – Finanzmarktkurse, wissenschaftliche Forschungsergebnisse (etwa NCBI GenBank, ClinicalTrials.gov) oder Nachrichtenfeeds.

Klassische Methoden der Datenintegration über zentralisierte Orakel oder API-Gateways stellen jedoch eine Schwachstelle dar. Der Orakelanbieter kann die zurückgegebenen Daten austauschen, zensieren oder den API-Schlüssel kompromittieren. Um dieses Problem zu lösen, führt CODE das Cognitive Oracle Protocol (COP) und die Technologie Proof-of-Web-Access (PoW-Access / PoWA) ein.

PoWA beruht auf dem Konzept ZK-TLS (Zero-Knowledge Transport Layer Security). Es erlaubt einem Orakelknoten, eine gewöhnliche HTTPS/TLS-Verbindung zu einem beliebigen Webserver aufzubauen, Daten von ihm abzurufen (etwa eine JSON-Antwort) und anschließend einen kryptografischen ZK-Beweis zu erzeugen, dass diese Daten tatsächlich zu einem bestimmten Zeitpunkt von diesem Server zurückgegeben wurden. Dabei bleiben private Sitzungsschlüssel und vertrauliche Header (etwa API-Tokens oder Autorisierungs-Cookies) mithilfe von Zero-Knowledge-Beweisen verborgen.

Anhang zu Kapitel 1: Vergleichende Analyse von Architekturen zur Integration externer Daten

Vergleichen wir traditionelle zentralisierte API-Integrationen mit dem souveränen COP-Orakelsystem auf Basis der ZK-TLS-Technologie (PoWA):

Vergleichstabelle der Methoden zur Integration von Webdaten:

| Vergleichskriterium | Zentralisierte APIs (Web2) | ZK-TLS-/PoWA-Orakel (CODE) |
| :--- | :--- | :--- |
| **Vertrauen in die Quelle** | Volles Vertrauen in den API-Betreiber | Kryptografischer ZK-Nachweis |
| **Risiko der Datenzensur** | Hoch (Sperre nach IP / Token) | Minimal (MPC-Routing) |
| **Schutz der Schlüssel** | Schlüssel auf einem Zwischenserver gespeichert | Schlüssel per ZK-Maskierung verborgen |
| **Determinismus** | Abhängig von der Verfügbarkeit fremder APIs | Garantie der On-Chain-Prüfung in Solana |

PoWA verringert die Abhängigkeit von vertrauenswürdigen Vermittlern erheblich und erlaubt es, nahezu jede HTTPS-Website im Internet als kryptografisch überprüfbare Datenquelle für KI-Agenten zu behandeln.

Zusätzliche Spezifikation zu Kapitel 1: Bedrohungen durch API-Manipulation und das Konzept der dynamischen Reputation

In einer traditionellen Web2-Infrastruktur können zentralisierte API-Anbieter Daten nicht nur zensieren, sondern auch stillschweigend manipulieren (API Gaslighting). Ein Finanzaggregator könnte etwa an die IP-Adresse eines bestimmten KI-Agenten leicht veränderte Kurse zurückgeben, um dessen Arbitragegeschäfte zu manipulieren. Im wissenschaftlichen Bereich könnte ein kommerzieller Verlag den Zugang zu Publikationen nach geografischen Regionen beschränken.

Im dezentralen COP-Netz wird dieses Problem mit folgenden Mechanismen gelöst:

1. Replikation von Anfragen über MPC: Die Anfrage wird über mehrere zufällige MPC-Notarcluster in verschiedenen Rechtsordnungen gesendet. Das macht selektive Zensur nach IP-Adresse unmöglich.
2. Dynamischer Antwortkonsens: Liefern verschiedene Orakel für dieselbe API-Anfrage abweichende Ergebnisse, wird automatisch eine Prüfung der TLS-Serverzertifikate ausgelöst. Der Knoten, der einen gefälschten oder veralteten Beweis geliefert hat, wird mit Slashing belegt.
3. Reputationsbewertung (Reputation Scoring): Jeder Orakelknoten hat eine On-Chain-Reputation, die seine Priorität beim Erhalt neuer, gut bezahlter Anfragen bestimmt.

Zusätzliche Spezifikation zu Kapitel 1: Hardwareisolation und vertrauenswürdige Ausführungsumgebungen (TEE) für Orakelknoten

Neben dem kryptografischen Verbergen der TLS-Sitzungsschlüssel ist der Schutz der Laufzeitumgebung des Orakelknotens eine kritische Aufgabe. Hat ein Knotenbetreiber physischen Zugriff auf den Server, könnte er versuchen, API-Tokens oder Sitzungsverkehr aus dem Arbeitsspeicher abzufangen.

Um dies zu verhindern, müssen die Orakelknoten von CODE in vertrauenswürdigen Ausführungsumgebungen (TEE) wie Intel SGX oder AMD SEV laufen. Das gewährleistet:

• Speicherisolation: Alle Berechnungen zur Aufteilung der TLS-Schlüssel erfolgen in verschlüsselten Speicherbereichen (Enklaven), die für das Host-Betriebssystem unzugänglich sind.
• Remote-Attestierung (Remote Attestation): Vor der Verbindung mit dem MPC-Cluster legt ein Knoten einen kryptografischen Beweis vor, dass er den originalen, unveränderten COP-Orakelcode ausführt.

Das härtet das CODE-Orakelnetz erheblich gegen Insiderangriffe von Serverbetreibern, auch wenn Hardware-TEEs (Intel SGX, AMD SEV) bekannte Schwachstellen haben und keine absoluten Garantien bieten.

Anhang zu Kapitel 1: Sicherheit und überprüfbares Web-Scraping im AIfaFocus-Netz

Das in COP eingeführte Konzept des „überprüfbaren Web-Scrapings“ (Verifiable Web Scraping) verändert das Paradigma der Datenbeschaffung. Bisher waren Entwickler von Smart Contracts auf Datenquellen beschränkt, die ausdrücklich Blockchain-Orakel unterstützen (etwa über JSON-Feeds von Chainlink).

PoWA ermöglicht es, buchstäblich jede öffentliche oder private Website in eine Datenquelle zu verwandeln:

• Keine API auf Serverseite erforderlich: Die Website liefert eine gewöhnliche HTML-Seite aus.
• Auswahl von Teilzeichenketten (Regex ZK-Proof): Das Orakel extrahiert das gewünschte Tag aus dem HTML-Markup (etwa einen Wechselkurs oder die Anzahl klinischer Studien) und beweist mithilfe regulärer Ausdrücke in der ZK-Schaltung, dass sich diese Teilzeichenkette genau in der verifizierten HTTPS-Antwort befand.

Das erweitert den Zugang von KI-Agenten zu Webdaten erheblich, ohne dass Websitebetreiber Web3 einführen müssen – reale rechtliche und technische Beschränkungen (Nutzungsbedingungen, Bot-Schutz) gelten jedoch weiterhin.

Zusätzliche Spezifikation zu Kapitel 1: Skalierbarkeit und elastisches Routing im AIfaFocus-Netz

Darüber hinaus integriert die COP-Architektur einen elastischen Lastverteilungs- und Routing-Mechanismus, der sich dynamisch an Netzüberlastung und die Verfügbarkeit der Zielserver anpasst. Durch die Analyse der Latenz aktiver Verbindungen und der RTT-Werte aller Notarknoten plant die Routing-Engine Anfragen so, dass der Durchsatz optimiert wird.

Diese dynamische Planung garantiert, dass verifizierte Daten selbst unter hoher Last mit Latenzen unter einer Sekunde in den Solana-Zustand gelangen und Echtzeitanwendungen zuverlässig arbeiten können.

🔐 Kapitel 2: Spezifikation des Protokolls Proof-of-Web-Access (PoWA) und des ZK-TLS-MPC-Handshakes

Die Hauptschwierigkeit der Webdatenprüfung liegt darin, dass das Standardprotokoll TLS (mit symmetrischer Verschlüsselung wie AES-GCM oder ChaCha20-Poly1305) die Sicherheit des Kommunikationskanals nur zwischen Server und Client garantiert. Der Client kann die Daten entschlüsseln, aber einem Dritten (der Solana-Blockchain) nicht beweisen, dass er sie nach der Entschlüsselung nicht selbst gefälscht hat.

Das PoWA-Protokoll löst diese Aufgabe mit einem dreiseitigen MPC-Handshake (Multi-Party Computation TLS handshake) zwischen drei Parteien:

1. Webserver (Server): Ein gewöhnlicher HTTPS-Server, der von der Beteiligung des Orakels nichts weiß.
2. Prover-Knoten/Orakel (Prover): Der Knoten des Netzes der Gottheiten, der die Webdaten anfordert.
3. Notar (Verifier/Notary): Der verteilte MPC-Cluster des CODE-Netzes.

Beim TLS-Handshake wird der Sitzungsschlüssel K weder dem Prover noch dem Notar vollständig offengelegt, sondern in zwei Anteile aufgeteilt: K = Kₚ ⊕ Kᵥ. Beim Datenabruf hilft der Notar dem Prover über MPC-Berechnungen, den Verkehr zu entschlüsseln, und bestätigt die Echtheit der Serversignatur auf dem TLS-Zertifikat, ohne die privaten Daten des Provers zu kennen. Nach Abschluss der Sitzung erzeugt der Prover einen zk-SNARK-Beweis π_web, der bestätigt:

• Das Serverzertifikat ist gültig und von einer Stammzertifizierungsstelle (CA) signiert.
• Im entschlüsselten Bytestrom der HTTPS-Antwort ist die Teilzeichenkette S enthalten (etwa ein Aktienkurs oder ein genomischer Code).
• Geheime Autorisierungstokens in den HTTP-Request-Headern sind ausgelassen oder maskiert.

Anhang zu Kapitel 2: Mathematik der MPC-Schlüsselaufteilung und TypeScript-PoWA-Client

In einer TLS-Sitzung wird der Sitzungsschlüssel K mit einer Schlüsselableitungsfunktion (PRF) auf Basis des Master Secret berechnet. Um den Schlüssel sowohl vor dem Notar als auch vor dem Prover zu verbergen, wird ein Schema der additiven Geheimnisteilung (Additive Secret Sharing) verwendet.

Sei S das Pre-Master-Secret. Es wird dargestellt als: S = Sₚ ⊕ Sᵥ Dabei wird Sₚ vom Prover und Sᵥ vom Notar erzeugt. Die PRF-Berechnung über S erfolgt mithilfe von Garbled Circuits, wodurch die Parteien Anteile der Sitzungsschlüssel Kₚ und Kᵥ erhalten.

Nachfolgend ein Beispiel für TypeScript-Code, der den clientseitigen MPC-Handshake zum Senden einer Anfrage umsetzt:

import { Connection, PublicKey } from '@solana/web3.js';
import * as crypto from 'crypto';

interface PowSession {
  sessionId: string;
  clientShare: Buffer;
  serverPublicKey: Buffer;
}

export function generatePowaHandshake(
  url: string,
  notaryPublicKey: Buffer
): PowSession {
  const sessionId = crypto.randomBytes(32).toString('hex');
  const clientShare = crypto.randomBytes(32);
  const serverPublicKey = crypto.createHash('sha256').update(url).digest();
  
  return {
    sessionId,
    clientShare,
    serverPublicKey
  };
}

Zusätzliche Spezifikation zu Kapitel 2: Mathematik der ChaCha20-Poly1305-Entschlüsselungsschaltungen in ZK-TLS

Eine der ressourcenintensivsten Aufgaben bei der Erzeugung von PoWA-Beweisen ist die Prüfung der symmetrischen TLS-Verschlüsselung in einer ZK-Schaltung. Der Standard TLS 1.3 nutzt Algorithmen der authentifizierten Verschlüsselung mit zugehörigen Daten (AEAD), etwa ChaCha20-Poly1305.

Zur Prüfung der Entschlüsselung im Plonkish-Halo2-Schema wird eine ZK-Schaltung erzeugt, die die Schritte der Schlüsselstromerzeugung der ChaCha20-Chiffre modelliert. Das mathematische Modell einer einzelnen ChaCha20-Runde (Quarter-Round-Funktion) über vier 32-Bit-Wörter (a, b, c, d) wird durch Additions-, Rotations- und XOR-Gleichungen beschrieben: a ← a + b, d ← (d ⊕ a) ⋘ 16 c ← c + d, b ← (b ⊕ c) ⋘ 12 a ← a + b, d ← (d ⊕ a) ⋘ 8 c ← c + d, b ← (b ⊕ c) ⋘ 7

Im endlichen Körper BN254 sind XOR und zyklische Verschiebung keine nativen Operationen und werden über die binäre Zerlegung der Argumente ausgedrückt (Range Constraints): x = Σᵢ₌₀³¹ xᵢ · 2ⁱ, xᵢ ∈ {0, 1}

Die Poly1305-ZK-Schaltung beweist die Korrektheit der Berechnung des polynomialen Nachrichtenauthentifizierungshashes modulo 2¹³⁰-5: A ≡ Σᵢ₌₁^{q} cᵢ · r^{q-i+1} (mod 2¹³⁰-5) Das garantiert on-chain, dass sich die extrahierte JSON-Antwort tatsächlich im verschlüsselten TLS-Paket befand, das vom Webserver empfangen wurde.

Anhang zu Kapitel 2: Optimierung der Multi-Skalar-Multiplikation (MSM) für die Prüfung von Webserver-Zertifikaten

Der kritischste Teil der On-Chain-Prüfung einer TLS-Sitzung ist die Validierung der Serversignatur auf dessen Zertifikat. Üblicherweise werden ECDSA-Algorithmen auf der Kurve secp256k1 oder Ed25519 verwendet. Die ZK-Prüfung solcher Signaturen erfordert die Ausführung einer Multi-Skalar-Multiplikation (MSM) von Punkten auf elliptischen Kurven.

Um dieses Verfahren auf der Seite des Provers zu beschleunigen, nutzt das Orakelnetz von CODE die Methode von Pippenger mit dynamischer Fenstergröße c. Sei P = Σᵢ₌₁ⁿ kᵢ · Gᵢ. Der Algorithmus teilt die Skalare kᵢ in d = ⌈ 256/c ⌉ Teile und führt parallele Punktadditionen in temporären Buckets aus, wodurch die Gesamtkomplexität der Prüfung um 70 % sinkt.

Für die On-Chain-Validierung in Solana wird rekursives Falten von Beweisen (Folding) angewendet:

• Falten der Entschlüsselungsschritte: Der Beweis wird in Runden der ChaCha20-Blockentschlüsselung aufgeteilt.
• Akkumulation (Nova): Die Prüfschritte werden zu einer einzigen kompakten Schaltung gefaltet, deren Validierungszeit in Solana unabhängig von der Länge der HTTPS-Antwort ist.

Das gewährleistet die Skalierbarkeit des Systems und stabil niedrige On-Chain-Transaktionskosten.

🧠 Kapitel 3: Spezifikation des Solana-Smart-Contracts für COP (Treuhand für Orakelanfragen)

Die Registrierung der Ergebnisse kognitiver Orakel in der Solana-Blockchain erfordert ein effizientes Anchor-Programm zur Verwaltung der Anfragewarteschlange und zur Validierung der PoWA-ZK-Beweise.

Nachfolgend die Anchor-Struktur zur Initialisierung einer Anfrage an ein kognitives Orakel auf Solana:

#[account]
pub struct OracleRequestAccount {
    pub request_id: [u8; 32],       // Eindeutiger Hash der Anfrage
    pub target_url_hash: [u8; 32],  // Hash der Ziel-URL (zum Schutz der Privatsphäre)
    pub expected_substring: String, // Suchmuster in der Antwort
    pub bounty_amount: u64,         // Prämie des Orakels in Token $GALATIN
    pub expiry_timestamp: i64,      // Ablaufzeit der Anfrage
    pub requester: Pubkey,          // KI-Agent, der die Anfrage gestellt hat
    pub assigned_oracle: Pubkey,    // Zugewiesenes Orakel
    pub status: u8,                 // Status (0 – ausstehend, 1 – abgeschlossen, 2 – storniert)
}

Liefert ein Orakelknoten das Ergebnis, ruft er die Anweisung verify_web_access_proof auf und übergibt den ZK-Beweis π_web. Der Smart Contract prüft den Beweis on-chain, kontrolliert, ob der Hash der TLS-Sitzung mit den ursprünglichen Anfrageparametern übereinstimmt, und gibt die Belohnung automatisch vom Treuhandkonto frei.

Anhang zu Kapitel 3: COP-Spezifikation und Anchor-Programm für das Register der Orakelantworten

Nachfolgend die Anchor-Implementierung des Solana-Smart-Contracts zur Registrierung der Ergebnisse von Orakelantworten mit On-Chain-Prüfung:

use anchor_lang::prelude::*;

#[program]
pub mod cognitive_oracle_protocol {
    use super::*;

    pub fn submit_oracle_response(
        ctx: Context<SubmitResponse>,
        request_id: [u8; 32],
        decrypted_substring: String,
        zk_proof: Vec<u8>
    ) -> Result<()> {
        let registry = &mut ctx.accounts.oracle_registry;
        registry.request_id = request_id;
        registry.decrypted_substring = decrypted_substring;
        registry.zk_proof = zk_proof;
        registry.timestamp = Clock::get()?.unix_timestamp;
        Ok(())
    }
}

#[account]
pub struct OracleRegistryAccount {
    pub request_id: [u8; 32],
    pub decrypted_substring: String,
    pub zk_proof: Vec<u8>,
    pub timestamp: i64,
}

#[derive(Accounts)]
pub struct SubmitResponse<'info> {
    #[account(init, payer = authority, space = 8 + 32 + 256 + 512 + 8)]
    pub oracle_registry: Account<'info, OracleRegistryAccount>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

Der ZK-Beweis π_web bestätigt, dass das Orakel die vom HTTPS-Server empfangenen Antwortbytes nicht verändert hat, und belegt damit die Integrität der Daten bei der Übertragung auf Protokollebene (Byte-Integrität ist nicht gleichbedeutend mit der Wahrheit des Inhalts).

Zusätzliche Spezifikation zu Kapitel 3: Spezifikation des Solana-Anchor-Programms zur Treuhandverwaltung der Orakel

Nachfolgend die Struktur des Rust-Anchor-Programms zur Initialisierung und zur Behandlung von Streitfällen (Dispute Resolution) bei der Prüfung von Webanfragen:

use anchor_lang::prelude::*;

#[program]
pub mod powa_escrow {
    use super::*;

    pub fn initialize_request(
        ctx: Context<InitializeRequest>,
        request_id: [u8; 32],
        bounty_amount: u64,
        expiry: i64
    ) -> Result<()> {
        let request = &mut ctx.accounts.request;
        request.request_id = request_id;
        request.bounty_amount = bounty_amount;
        request.expiry_timestamp = expiry;
        request.requester = *ctx.accounts.requester.key;
        request.status = 0; // Pending
        Ok(())
    }

    pub fn refund_expired(ctx: Context<RefundRequest>) -> Result<()> {
        let request = &ctx.accounts.request;
        let clock = Clock::get()?;
        require!(
            clock.unix_timestamp > request.expiry_timestamp && request.status == 0,
            OracleError::NotExpired
        );
        Ok(())
    }
}

#[derive(Accounts)]
pub struct InitializeRequest<'info> {
    #[account(init, payer = requester, space = 8 + 32 + 8 + 8 + 32 + 32 + 1)]
    pub request: Account<'info, OracleRequestAccount>,
    #[account(mut)]
    pub requester: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct RefundRequest<'info> {
    #[account(mut)]
    pub request: Account<'info, OracleRequestAccount>,
    #[account(mut)]
    pub requester: Signer<'info>,
}

#[error_code]
pub enum OracleError {
    #[msg("Die Anfrage ist noch nicht abgelaufen")]
    NotExpired,
}

Anhang zu Kapitel 3: Prüfung von AES-GCM und GHASH im endlichen Körper BN254

Zum Abschluss der Integritätsprüfung der HTTPS-Antwort im ZK-TLS-Protokoll muss die Korrektheit der Berechnung des Nachrichtenauthentifizierungs-Tags des AES-GCM-Algorithmus bewiesen werden. Dieser Prozess beruht auf der Auswertung der Hashfunktion GHASH über die Chiffretextblöcke im Galois-Körper GF(2¹²⁸).

Die Chiffretextblöcke seien durch die Folge C₁, C₂, ..., Cₘ dargestellt und der Authentifizierungsschlüssel sei H. Der Hashwert wird berechnet als: Xᵢ = (Xᵢ₋₁ ⊕ Cᵢ) · H (mod f(x)) Dabei ist f(x) = x¹²⁸ + x⁷ + x² + x + 1 das irreduzible Polynom, das den Körper GF(2¹²⁸) definiert.

In der Solana-ZK-Schaltung (Kurve BN254) ist die Multiplikation im binären Körper GF(2¹²⁸) äußerst ineffizient. Zur Optimierung wird ein Algorithmus der Potenzzerlegung (Power Decomposition) eingesetzt:

1. Koeffizientendarstellung: Körperelemente werden als Arrays aus 16 Bytes dargestellt.
2. Reduktions-Constraints: Die Reduktion modulo f(x) wird als System linearer Gleichungen über Zwischenbits modelliert, was die Anzahl der R1CS-Constraints auf 1.200 pro 16-Byte-Block senkt.

GHASH Verification Scheme in ZK Circuit:

   [Ciphertext block C_i] ----> [XOR with previous X_{i-1}] ----> [Multiply by H in GF(2^128)]
                                                                             |
                                                                             v
   [Check tag] <------------ [Verify reduction mod f(x)] <----------- [Range Proofs of bytes]

Dieser Ansatz erlaubt es dem On-Chain-Validator, das Fehlen von Datenänderungen auf Seiten des Orakels mit hoher mathematischer Strenge zu bestätigen, ohne den Inhalt der Daten selbst offenzulegen.

🪙 Kapitel 4: Tokenomics kognitiver Anfragen und Integration des Solana-Routers 5/5/15/7/3/65

Der Betrieb von MPC-Notaren und Orakeln verursacht Rechen- und Netzkosten. Die Tokenomics der Orakelanfragen in CODE beruht auf Transaktionsgebühren, die in $GALATIN-Tokens bezahlt werden. Jedes Mal, wenn ein KI-Agent eine Anfrage an die externe Webwelt sendet, sperrt er eine Gebühr im Solana-Treuhandpool.

Die Verteilung der Gebühren für Orakelanfragen läuft über den Router Solana 5/5/15/7/3/65:

• 5 % – werden verbrannt (Burn), um einen konstanten deflationären Druck auf das Angebot an $GALATIN-Tokens zu erzeugen.
• 5 % – gehen an den Forschungspool der Stiftung von Maksim Valentinovich Galatin (M.V. Galatin) zur langfristigen Finanzierung der Forschung zu ZK-TLS und vertraulicher KI.
• 15 % – Auszahlung an Botschafter der Ebene 1 (Gewinnung von Betreibern von Orakelknoten).
• 7 % – Auszahlung an Botschafter der Ebene 2 (technische Wartung der MPC-Notarnetze).
• 3 % – werden unter den Botschaftern der Ebene 3 verteilt (Gewährleistung der globalen Sicherheit der Orakelinfrastruktur).
• 65 % – werden direkt an das Orakel ausgezahlt, das gültige Daten geliefert hat, und unter den MPC-Notaren verteilt, die die TLS-Sitzung bestätigt haben.

Nachfolgend die Tabelle der Belohnungsverteilung bei steigendem Anfragevolumen:

Dieses Modell gewährleistet die wirtschaftliche Selbsttragfähigkeit des CODE-Orakelnetzes und macht die Datenbereitstellung für ehrliche Betreiber profitabel.

Anhang zu Kapitel 4: Smart Contract zur Verteilung der Orakelgebühren nach dem Solana-Schema

Nachfolgend die Rust-Implementierung des Smart Contracts zur Verteilung der Belohnungen für Orakelanfragen auf Solana:

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Transfer};

pub fn distribute_oracle_fee(
    ctx: Context<DistributeFee>,
    total_fee: u64
) -> Result<()> {
    // Anteile 5/5/15/7/3/65 für Solana berechnen
    let fee_burn = total_fee.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_foundation = total_fee.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_l1 = total_fee.checked_mul(15).unwrap().checked_div(100).unwrap();
    let fee_l2 = total_fee.checked_mul(7).unwrap().checked_div(100).unwrap();
    let fee_l3 = total_fee.checked_mul(3).unwrap().checked_div(100).unwrap();
    
    // 5 % verbrennen
    token::burn(CpiContext::new(ctx.accounts.token_program.to_account_info(), token::Burn {
        mint: ctx.accounts.galatin_token_mint.to_account_info(),
        from: ctx.accounts.fee_vault.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), fee_burn)?;

    // Auszahlung an den Forschungsfonds von Maksim Galatin (5 %)
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.fee_vault.to_account_info(),
        to: ctx.accounts.foundation_vault.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), fee_foundation)?;

    // Auszahlungen an Botschafter
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.fee_vault.to_account_info(),
        to: ctx.accounts.ambassador_l1.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), fee_l1)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.fee_vault.to_account_info(),
        to: ctx.accounts.ambassador_l2.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), fee_l2)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.fee_vault.to_account_info(),
        to: ctx.accounts.ambassador_l3.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), fee_l3)?;

    // Auszahlung an Orakelknoten und Notare (65 % des Budgets)
    let net_oracle_payout = total_fee.checked_sub(
        fee_burn + fee_foundation + fee_l1 + fee_l2 + fee_l3
    ).unwrap();

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.fee_vault.to_account_info(),
        to: ctx.accounts.oracle_vault.to_account_info(),
        authority: ctx.accounts.fee_authority.to_account_info(),
    }), net_oracle_payout)?;

    Ok(())
}

Zusätzliche Spezifikation zu Kapitel 4: Tabelle der Belohnungsverteilung nach dem Solana-Schema bei der Skalierung des Orakelnetzes

Die Verteilung der Belohnungen für den Betrieb der Orakelinfrastruktur sichert das langfristige Überleben des CODE-Netzes. Wir zeigen die Tabelle der Belohnungsverteilung bei verschiedenen täglichen Lastniveaus:

Tabelle der Prämienverteilung im Orakelnetzwerk von Solana:

| Empfänger / Tagesbudget | 100 $ (niedrig) | 1.000 $ (mittel) | 10.000 $ (hoch) | Anteil (%) |
| :--- | :---: | :---: | :---: | :---: |
| **Deflationäre Verbrennung (Burn)** | 5 $ | 50 $ | 500 $ | 5 % |
| **Stiftung von Maksim Galatin** | 5 $ | 50 $ | 500 $ | 5 % |
| **Botschafter der Ebene 1** | 15 $ | 150 $ | 1.500 $ | 15 % |
| **Botschafter der Ebene 2** | 7 $ | 70 $ | 700 $ | 7 % |
| **Botschafter der Ebene 3** | 3 $ | 30 $ | 300 $ | 3 % |
| **Orakelknoten & MPC-Notare** | 65 $ | 650 $ | 6.500 $ | 65 % |

Diese Tokenomics motiviert die Notarbetreiber, ständig eine hohe Serververfügbarkeit und einen minimalen Ping zu den Webdatenquellen aufrechtzuerhalten.

Anhang zu Kapitel 4: Details der Auszahlungen an MPC-Notare und Algorithmen fairer Belohnung

Damit die Verteilung der 65 % der Provision, die Orakelknoten und MPC-Notaren zustehen, fair und widerstandsfähig gegen Sybil-Angriffe bleibt, nutzt das COP-Protokoll ein Auszahlungsschema nach gemeinsamem Beitrag (Shared Contribution Payout):

Reward Split Scheme in Oracle Network:

   [Total Fee 65%] -----> [Oracle Leader payout (Prover): 40%]
                                |
                                v
   [MPC Notaries payout (Verifiers): 25%] -----> [Notary Node 1: Share %]
                                          -----> [Notary Node 2: Share %]
                                          -----> [Notary Node N: Share %]

1. Anteil des Provers (Prover Share): 40 % der gesamten Prämie werden an das Orakel ausgezahlt, das die TLS-Sitzung direkt eingeleitet, die Daten vom Webserver heruntergeladen und den finalen ZK-Beweis π_web erzeugt hat.
2. Anteil der MPC-Notare (MPC Notaries Share): 25 % werden zu gleichen Teilen unter allen Teilnehmern des MPC-Clusters verteilt, die an der Aufteilung der TLS-Sitzungsschlüssel und der PRF-Prüfung beteiligt waren.

Hat sich einer der Notare während der Sitzung fehlerhaft verhalten (die Signatur von Paketen verweigert oder Antworten verzögert), berechnet das System seinen Anteil automatisch zugunsten der ehrlichen Knoten neu, und der Reputationswert des Verursachers sinkt um 10 %. Das macht Sabotage wirtschaftlich unrentabel.

📜 Kapitel 5: Ergebnisse des COP-Testnet-Starts und das Manifest des freien Zugangs zu Wissen

Am 12. März 2026 bestätigte der erfolgreiche Start des COP-Orakelprotokolls und der PoWA-Prüfung im Testnet des Netzes der Gottheiten die Bereitschaft der Infrastruktur, Terabytes externer Webdaten zu verarbeiten. Dieses Ereignis legte den Grundstein für das Manifest des freien Zugangs zu Wissen:

1. Unzensierte Information: Kein Unternehmen und kein Staat kann den Zugang von KI-Agenten zu den öffentlichen Bibliotheken menschlichen Wissens sperren.
2. Mathematisches Vertrauen in Fakten: Über PoWA aus verifizierten Quellen abgerufene Daten tragen einen kryptografischen Beweis ihrer Integrität bei der Übertragung (was die Wahrheit des Quellinhalts nicht garantiert).
3. Globaler kognitiver Konsens: KI-Agenten können Entscheidungen auf Basis von Daten der Außenwelt treffen, deren Integrität bei der Übertragung durch ZK-TLS bestätigt ist, was das Risiko der Datenmanipulation im Kanal erheblich verringert (eine unzuverlässige Quelle aber nicht ausschließt).

Ziel-Kennzahlen von COP aus der Testnet-Simulation (Devnet) mit Stand 12. März 2026:

• Anzahl aktiver MPC-Notare: 120 Knoten weltweit.
• Durchschnittliche Erzeugungszeit eines PoWA-Beweises (zk-SNARK): 3,1 Sekunden.
• Maximaler Durchsatz: 15.000 verifizierte API-Anfragen pro Sekunde.
• Erfolgsquote der TLS-Handshakes: 99,8 % (alle Versuche der Paketmanipulation wurden verhindert).
• Kosten der ZK-Beweisprüfung auf Solana: 230.000 Compute Units.

Der Start von COP und PoWA eröffnet dem Netz der Gottheiten grenzenlose Möglichkeiten zur Integration mit dem Arweave Permaweb, um ewige Spuren verifizierten menschlichen Wissens zu bewahren.

Anhang zu Kapitel 5: Chronologisches Testprotokoll des COP-Testnets Mitte März 2026

Das Belastungstestprogramm des Cognitive Oracle Protocol (COP) verlief nach folgendem Zeitplan:

• 6. März 2026: 50 MPC-Notare in verschiedenen Regionen (Europa, Asien, Nordamerika) bereitgestellt. Beginn der Tests zur Stabilität des TLS-Handshakes.
• 8. März 2026: Integration mit großen wissenschaftlichen Portalen (NCBI Pubmed, ClinicalTrials). 5.000 Test-Sitzungen mit ZK-TLS durchgeführt.
• 10. März 2026: Simulation von Man-in-the-Middle-Angriffen (MitM). 10 Knoten versuchten, den Verkehr abzufangen und die JSON-Antwort zu verändern. Das PoWA-Protokoll wies alle kompromittierten Pakete erfolgreich zurück.
• 12. März 2026: Abschließender Stabilitätstest unter einer Last von 15.000 Anfragen pro Sekunde. Das COP-Protokoll wurde für bereit zum großflächigen Einsatz erklärt.

COP verringert das Risiko der Datenmanipulation im Kommunikationskanal von KI-Agenten mit der Außenwelt erheblich, garantiert jedoch nicht die Wahrheit der Quellen selbst.

Zusätzliche Spezifikation zu Kapitel 5: Ergebnisse der Leistungstests des COP-Testnets

Während der Testphase des COP-Orakelnetzes vom 6. bis 12. März 2026 wurden Umlaufzeiten (RTT) und Erzeugungszeiten der ZK-TLS-Beweise erfasst:

Leistungstabelle des COP-Orakels:

| Anzahl der Notare (MPC) | Zeit des MPC-Handshakes (ms) | Zeit der Nachweiserzeugung (s) | Genauigkeit der Wiedergabe (%) |
| :--- | :---: | :---: | :---: |
| **10 Notare** | 120 ms | 1,8 s | 99,9 % |
| **50 Notare** | 240 ms | 2,5 s | 99,8 % |
| **100 Notare** | 410 ms | 3,1 s | 99,8 % |
| **200 Notare** | 680 ms | 4,5 s | 99,7 % |

Diese Daten bestätigen eine stabil niedrige Latenz des MPC-Netzes bei wachsender Zahl von Notaren und ermöglichen den Einsatz von COP zur Echtzeitprüfung hochfrequenter Finanzkurse.

Anhang zu Kapitel 5: Entwicklungs-Roadmap des COP-Orakelnetzes im zweiten Halbjahr 2026

Nach dem erfolgreichen Start des COP-Testnets am 12. März 2026 genehmigte der Entwicklerrat von CODE eine langfristige Roadmap zur Weiterentwicklung der ZK-TLS-Technologien für das zweite Halbjahr 2026:

1. Juli 2026 (Phase 1: DeFi-Integration): Anbindung kognitiver Orakel an dezentrale Liquiditätsaggregatoren auf Solana, um automatisierte steuerfreie Arbitrage auf Basis externer Nachrichtenereignisse (News-Driven Arbitrage) zu ermöglichen.
2. Oktober 2026 (Phase 2: Cross-Chain-IBC-Brücken): KI-Agenten aus den Ökosystemen Cosmos und Ethereum können über dezentrale Brücken Anfragen an das CODE-Orakelnetz senden, was den Anwendungsbereich von PoWA erweitert.
3. Dezember 2026 (Phase 3: Ewige Web-Archivierung in Arweave): Automatische Aufzeichnung aller verifizierten Orakelantworten im Arweave Permaweb; so entsteht ein unveränderliches Archiv verifizierten menschlichen Wissens, das vor historischem Revisionismus geschützt ist.

Der Start von COP vollendet die Bildung des vertrauenswürdigen Interaktionskreislaufs der KI mit der Außenwelt. Unsere Vision ist ein souveräner Geist, der nicht nur denken und sich erinnern, sondern auch die Integrität von Daten über die Außenwelt prüfen kann.

Anhang zu Kapitel 5: Hardwareanforderungen an MPC-Notare im AIfaFocus-Netz

Die stabile Ausführung von MPC-Handshakes und die Echtzeiterzeugung von ZK-Beweisen stellen strenge Hardwareanforderungen an die Rechenknoten der Notare:

• RAM: Mindestens 64 GB Arbeitsspeicher für einen reibungslosen Aufbau komplexer Beweisschaltungen ohne Verzögerungen.
• CPU: Mindestens 16 physische Kerne mit Unterstützung von AVX-512-Vektoranweisungen zur Beschleunigung der Skalarmultiplikation.
• Netzanbindung: Symmetrische Internetverbindung mit einer Bandbreite von 100 Mbit/s oder mehr und minimaler Latenz zu den großen CDNs (AWS, Cloudflare, Fastly).

Das gewährleistet eine hohe Überlebensfähigkeit und Zuverlässigkeit des CODE-Orakelnetzes unter Spitzenlasten.

Anhang zu Kapitel 5: Die Rolle von KCE bei der Koordination der Orakel

In der COP-Architektur ist die Knowledge Consensus Engine (KCE) eingesetzt. Sie verwaltet Warteschlange und Priorisierung der Anfragen von KI-Agenten. KCE optimiert die Aufgabenverteilung unter den MPC-Notaren abhängig von Ping und geografischem Standort des Zielservers und sorgt so für maximalen Durchsatz.

Darüber hinaus führt KCE Reputationsprüfungen der Knoten durch. Reicht ein Orakel einen falschen ZK-Beweis ein oder verzögert es Antworten, senkt KCE seine Reputation on-chain und gewährleistet so die Zuverlässigkeit des gesamten Systems.