std.blockchain — Blockchain-Kern (Serializer, Modelle, Ledger, Konsens)

std.blockchain implementiert eine vollständige Proof-of-Work-Blockchain in Lyx — ohne externe Bibliotheken. Die Unit ist in vier Module aufgeteilt, die aufeinander aufbauen:

P2P-Netzwerk: → std.blockchain.p2p

→ Standard Library · std.crypto · Welche Unit?

Kryptographische Grundlagen:

• Public Key = 64 Bytes (X||Y, unkomprimierter secp256k1-Punkt)
• Private Key = 32 Bytes
• Adresse = SHA-256(Public Key), 32 Bytes — kein Base58, keine Checksums
• Signatur = R||S compact, 64 Bytes (ECDSA secp256k1)
• Alle Hashes = SHA-256, 32 Bytes

Beträge:

• Alle Beträge in Basis-Einheiten: 1 Coin = BL_BASE_UNIT = 1.000.000
• Kein Gleitkomma — alle Rechnungen in int64

Immutable Ledger-Pattern:

• BLApplyTransaction und BLApplyBlock geben neue Ledger-Pointer zurück
• Der alte Ledger bleibt unverändert und muss vom Aufrufer freigegeben werden
• Atomare Block-Anwendung: bei Fehler mitten im Block wird kein Zwischenzustand gespeichert

Offset-Konstanten: BL_TX_SENDER_ADDR (0), BL_TX_SENDER_PUB (32), BL_TX_RECV_ADDR (96), BL_TX_AMOUNT (128), BL_TX_FEE (136), BL_TX_NONCE (144), BL_TX_TIMESTAMP (152), BL_TX_SIG (160), BL_TX_SIZE (224)

Offset-Konstanten: BL_BLK_INDEX (0), BL_BLK_TIMESTAMP (8), BL_BLK_PREV_HASH (16), BL_BLK_MERKLE (48), BL_BLK_NONCE (80), BL_BLK_DIFFICULTY (88), BL_BLK_HASH (96), BL_BLK_TX_COUNT (128), BL_BLK_TX_PTRS (136), BL_BLK_SIZE (144)

Der Ledger ist eine feste Hash-Tabelle mit 1024 Buckets und linearem Probing. Er speichert Guthaben und Nonce pro Adresse.

Bucket-Offsets: BL_BUCKET_ADDR (0), BL_BUCKET_BALANCE (32), BL_BUCKET_NONCE (40), BL_BUCKET_USED (48)

BLMerkleRoot-Details:

• Leere Transaktionsliste → SHA-256 des leeren Puffers
• Ungerade Anzahl → letztes Blatt wird dupliziert (Bitcoin-Konvention)

Workflow für manuelles Mining:

// 1. Block erstellen (hash-Feld = Null)
var block: int64 := BLNewBlock(index, prevHash, txPtrs, txCount, diff);

// 2. PoW-Schleife
var hashBuf: int64 := alloc(32);
while 1 == 1 do {
    BLCalculateHash(block, hashBuf);
    if BLMeetsTarget(hashBuf, diff) == 1 then { break; }
    poke64(block + BL_BLK_NONCE, peek64(block + BL_BLK_NONCE) + 1);
}
// 3. Hash in Block schreiben
var i: int64 := 0;
while i < 32 do { poke8(block + BL_BLK_HASH + i, peek8(hashBuf + i)); i := i + 1; }
free(hashBuf, 32);

BLApplyTransaction prüft:

1. Nonce = erwartetem Wert (verhindert Replay)
2. Betrag und Gebühr ≥ 0
3. ''balance(sender) ≥ amount + fee''
* Coinbase: überspringt alle Prüfungen, schreibt direkt dem Empfänger gut

Offset-Konstanten: BL_BC_LEDGER (0), BL_BC_DIFFICULTY (8), BL_BC_REWARD (16), BL_BC_MAX_TX (24), BL_BC_CHAIN_COUNT (32), BL_BC_CHAIN_CAP (40), BL_BC_CHAIN_BLKS (48), BL_BC_MEMPOOL_CNT (56), BL_BC_MEMPOOL_CAP (64), BL_BC_MEMPOOL_TXS (72), BL_BC_SIZE (80)

BLAddTransaction prüft in dieser Reihenfolge:

1. Kein Coinbase (wird abgelehnt)
2. SHA-256(senderPubKey) = senderAddr
3. ECDSA-Signatur gültig
4. Nonce = aktuellem Wert im Ledger
5. amount ≥ 0 und fee ≥ 0
6. balance ≥ amount + fee
7. Kein Duplikat im Mempool (via TX-Hash)

1. Bis ''maxTxPerBlock'' TXs aus Mempool (FIFO — keine Gebühren-Sortierung)
2. Gebühren summieren
3. Coinbase-TX erstellen: Betrag = ''reward + totalFees''
4. Block erstellen: [coinbase] + ausgewählte TXs
5. **PoW-Schleife** (blockiert): Nonce erhöhen bis ''BLMeetsTarget == 1''
6. Block auf Ledger anwenden
7. Block an Kette anhängen, verwendete TXs aus Mempool entfernen
8. Schwierigkeit anpassen (wenn ''chainCount % BL_DIFFICULTY_INTERVAL == 0'')

Alle 10 Blöcke: newDiff = (difficulty × expected_time) / actual_time

• Maximale Änderung pro Intervall: Faktor 4 (hoch oder runter)
• Minimum: BL_MIN_DIFFICULTY = 1
• Zielzeit: 10 Sekunden pro Block

import std.blockchain;
import std.crypto.ecc;
import std.crypto.sha256;
import std.alloc;
import std.io;

fn main(): int64 {
    // Blockchain erstellen: Schwierigkeit 1, Belohnung 50 Coins, max 10 TXs/Block
    var bc: int64 := BLBlockchainNew(1, 50 * BL_BASE_UNIT, 10);

    // Alice: Schlüsselpaar erstellen
    var alicePriv: int64 := alloc(BL_PRIVKEY_LEN);
    var alicePub:  int64 := alloc(BL_PUBKEY_LEN);
    ECCGenerateKeyPair(alicePriv, alicePub);

    // Alice' Adresse = SHA-256(pubKey)
    var aliceAddr: int64 := alloc(BL_ADDR_LEN);
    SHA256(alicePub, BL_PUBKEY_LEN, aliceAddr);

    // Bob: Schlüsselpaar erstellen
    var bobPriv: int64 := alloc(BL_PRIVKEY_LEN);
    var bobPub:  int64 := alloc(BL_PUBKEY_LEN);
    ECCGenerateKeyPair(bobPriv, bobPub);
    var bobAddr: int64 := alloc(BL_ADDR_LEN);
    SHA256(bobPub, BL_PUBKEY_LEN, bobAddr);

    // Genesis-Block minen — Alice erhält Mining-Belohnung (50 Coins)
    BLMinePendingTransactions(bc, aliceAddr);

    Print("Alice: "c);
    PrintLn(IntToStr(BLBlockchainGetBalance(bc, aliceAddr) / BL_BASE_UNIT)c);

    // TX: Alice schickt 10 Coins an Bob (1 Coin Gebühr)
    var nonce: int64 := BLBlockchainGetNonce(bc, aliceAddr);
    var tx: int64    := BLNewTransaction(alicePub, bobAddr,
                                        10 * BL_BASE_UNIT,   // amount
                                        1 * BL_BASE_UNIT,    // fee
                                        nonce);
    BLSignTransaction(tx, alicePriv);

    var ok: int64 := BLAddTransaction(bc, tx);
    if ok == 0 then {
        PrintLn("TX abgelehnt"c);
        BLTxFree(tx);   // bei Ablehnung: Aufrufer gibt frei
    }

    // Zweiten Block minen
    BLMinePendingTransactions(bc, aliceAddr);

    Print("Alice: "c); PrintLn(IntToStr(BLBlockchainGetBalance(bc, aliceAddr) / BL_BASE_UNIT)c);
    Print("Bob:   "c); PrintLn(IntToStr(BLBlockchainGetBalance(bc, bobAddr)   / BL_BASE_UNIT)c);
    Print("Kette: "c); PrintLn(IntToStr(BLChainLength(bc))c);
    Print("Gültig: "c); PrintLn(IntToStr(BLIsValidChain(bc))c);

    free(alicePriv, BL_PRIVKEY_LEN);
    free(alicePub,  BL_PUBKEY_LEN);
    free(aliceAddr, BL_ADDR_LEN);
    free(bobPriv,   BL_PRIVKEY_LEN);
    free(bobPub,    BL_PUBKEY_LEN);
    free(bobAddr,   BL_ADDR_LEN);
    BLBlockchainFree(bc);
    return 0;
}

• PoW blockiert: BLMinePendingTransactions kehrt erst zurück wenn ein gültiger Hash gefunden wurde. Bei hoher Schwierigkeit kann das Sekunden bis Minuten dauern.
• Ledger-Kapazität: Maximal 1024 Adressen (feste Hash-Tabelle). Für größere Netzwerke muss BL_LEDGER_CAP angepasst werden.
• Keine Netzwerkschicht: Diese Unit ist lokal. P2P-Kommunikation → std.blockchain.p2p
• Keine Persistenz: Blockchain liegt vollständig im RAM. Für Persistenz: eigene Serialisierung via BLSerializeInt64/Int32 + Dateisystem.
• Kein UTXO: Der Ledger nutzt ein kontobasiertes Modell (wie Ethereum), kein UTXO-Modell (wie Bitcoin).
• Kein Fee-Markt: BLMinePendingTransactions wählt TXs per FIFO, nicht nach Gebühren.

Letzte Aktualisierung: 2026-06-13