Einführung in die Transaktionsvalidierung mit SimpleCoin2 – Ein praktischer Leitfaden für CSCI 181

Einführung in die Transaktionsvalidierung mit SimpleCoin2

In diesem Tutorial lernst du die Grundlagen der Transaktionsvalidierung am Beispiel von SimpleCoin2 – einem vereinfachten Kryptowährungsprotokoll. Du wirst eine PayCoin-Transaktion modellieren, eine einfache Blockchain erstellen und eine Validierungsfunktion schreiben, die prüft, ob eine Transaktion gültig ist. Dieses Wissen ist nicht nur für deine Hausaufgabe in CSCI 181 relevant, sondern auch für aktuelle Trends wie Kryptowährungen, DeFi und Blockchain-Apps. Stell dir vor, du entwickelst eine Mini-App, die Zahlungen in einer Gaming-Community verarbeitet – genau solche Konzepte wendest du hier an.

1. Die PayCoin-Transaktionsklasse (10 Punkte)

Zunächst benötigst du eine Datenstruktur, die eine Transaktion repräsentiert. Eine PayCoin-Transaktion enthält folgende Felder: Absender (public key des Senders), Empfänger (public key des Empfängers), Betrag, eine eindeutige Transaktions-ID, einen Zeitstempel und eine digitale Signatur. In Java könnte die Klasse so aussehen:

public class PayCoinTransaction {
    public String senderPubKey;
    public String recipientPubKey;
    public double amount;
    public String txId;
    public long timestamp;
    public byte[] signature;

    // Konstruktor
    public PayCoinTransaction(String sender, String recipient, double amount, String txId) {
        this.senderPubKey = sender;
        this.recipientPubKey = recipient;
        this.amount = amount;
        this.txId = txId;
        this.timestamp = System.currentTimeMillis();
    }
}

Der timestamp hilft, die Reihenfolge der Transaktionen zu bestimmen. Die txId sollte eindeutig sein, zum Beispiel als Hash der Transaktionsdaten vor der Signatur. In der Praxis wird die txId oft aus den Daten berechnet, aber hier kannst du sie einfach als String übergeben. Die Signatur wird später gesetzt, wenn der Sender die Transaktion signiert.

2. Die Blockchain (Ledger) – 10 Punkte

Die Blockchain ist eine verkettete Liste von Blöcken. Jeder Block enthält einen Header und eine Liste von Transaktionen. Für diese Aufgabe nehmen wir an, dass jeder Block genau eine PayCoin-Transaktion enthält. Du brauchst keine Hashes zu berechnen, aber die Struktur sollte trotzdem klar sein:

public class Block {
    public int index;
    public String previousHash;
    public PayCoinTransaction transaction;
    public long timestamp;
    public String hash; // optional, hier nicht berechnet

    public Block(int index, String previousHash, PayCoinTransaction tx) {
        this.index = index;
        this.previousHash = previousHash;
        this.transaction = tx;
        this.timestamp = System.currentTimeMillis();
    }
}

public class Blockchain {
    public ArrayList<Block> chain;

    public Blockchain() {
        chain = new ArrayList<>();
        // Genesis-Block
        chain.add(new Block(0, "0", null));
    }
}

Die Blockchain wird als ArrayList von Blöcken implementiert. Der Genesis-Block hat Index 0 und keinen Vorgänger. Später fügst du neue Blöcke nur hinzu, wenn die Transaktion gültig ist.

3. Validierungsfunktion (32 Punkte)

Der Kern der Aufgabe ist die Funktion, die prüft, ob eine neue Transaktion gültig ist. Laut Vorlesung ist eine Transaktion gültig, wenn:

• Die Signatur mit dem öffentlichen Schlüssel des Senders übereinstimmt.
• Der Sender ausreichend Guthaben hat (d.h. die Summe seiner ausgehenden Transaktionen ist kleiner oder gleich der Summe der eingehenden Transaktionen).
• Die Transaktion nicht doppelt ist (keine Transaktion mit derselben txId existiert bereits).
• Der Betrag positiv ist.

Da du Zugriff auf alle öffentlichen Schlüssel hast und eine verifySignature-Funktion existiert, kannst du die Signaturprüfung delegieren. Die Guthabenprüfung erfordert, dass du den Kontostand des Senders aus der Blockchain berechnest. Hier ein möglicher Ansatz:

public boolean isValidTransaction(PayCoinTransaction tx, Blockchain ledger) {
    // 1. Signatur prüfen
    String message = tx.senderPubKey + tx.recipientPubKey + tx.amount + tx.txId + tx.timestamp;
    if (!verifySignature(tx.senderPubKey, message, tx.signature)) {
        System.out.println("Ungültige Signatur");
        return false;
    }

    // 2. Doppelte Transaktion ausschließen
    for (Block block : ledger.chain) {
        if (block.transaction != null && block.transaction.txId.equals(tx.txId)) {
            System.out.println("Transaktion existiert bereits");
            return false;
        }
    }

    // 3. Guthaben prüfen
    double balance = 0;
    for (Block block : ledger.chain) {
        if (block.transaction != null) {
            if (block.transaction.recipientPubKey.equals(tx.senderPubKey)) {
                balance += block.transaction.amount;
            }
            if (block.transaction.senderPubKey.equals(tx.senderPubKey)) {
                balance -= block.transaction.amount;
            }
        }
    }
    if (balance < tx.amount) {
        System.out.println("Nicht genug Guthaben");
        return false;
    }

    // 4. Betrag positiv
    if (tx.amount <= 0) {
        System.out.println("Betrag muss positiv sein");
        return false;
    }

    return true;
}

Wenn die Transaktion gültig ist, erstellst du einen neuen Block und fügst ihn der Blockchain hinzu:

public void addTransaction(PayCoinTransaction tx, Blockchain ledger) {
    if (isValidTransaction(tx, ledger)) {
        Block newBlock = new Block(ledger.chain.size(), 
                                   ledger.chain.get(ledger.chain.size()-1).hash, 
                                   tx);
        ledger.chain.add(newBlock);
        System.out.println("Transaktion erfolgreich hinzugefügt");
    } else {
        System.out.println("Transaktion abgelehnt");
    }
}

Wichtige Hinweise und Erweiterungen

In der Praxis werden Blockchains wie Bitcoin oder Ethereum viel komplexer sein, aber das Grundprinzip der Transaktionsvalidierung bleibt gleich. Aktuelle Trends wie NFTs oder Smart Contracts bauen auf solchen Basismechanismen auf. Stell dir vor, du entwickelst ein Spiel, in dem Spieler In-Game-Währungen tauschen – deine Validierungslogik stellt sicher, dass niemand mehr ausgibt, als er hat.

Vergiss nicht, ausreichend Kommentare in deinen Code zu schreiben, damit dein Tutor sieht, dass du verstehst, was du tust. Die Kommentare sollten erklären, warum du bestimmte Prüfungen durchführst und wie sie zur Sicherheit des Systems beitragen.

Zusammenfassung

In diesem Tutorial hast du gelernt, wie man eine PayCoin-Transaktion modelliert, eine einfache Blockchain erstellt und eine Validierungsfunktion implementiert. Diese Konzepte sind zentral für viele moderne Anwendungen im Bereich Kryptowährungen und verteilte Systeme. Viel Erfolg bei deiner Hausaufgabe!