Auf der Suche nach Nonces mit geraden Zahlen

Ich denke, dass Tim S. mit seinem Kommentar zur Endianness die Antwort hat.

Ihre Beobachtungen darüber, dass die Nonce ihr niedrigstes Byte Null hat (ein Vielfaches von 256), beziehen sich auf die Little-Endian-Byte-Reihenfolge des Blocks selbst. Aus Sicht einer Big-Endian-Maschine sind dies Aussagen über das High - Byte der Nonce.

Betrachten Sie also einen Bergmann, der Big-Endian ist. Der natürliche Algorithmus ist "start with nonce=0, compute scrypt, increment nonce, repeat", also werden Ihre "geraden" Nonces zuerst versucht. Wenn jedoch eine neue Transaktion (oder ein neuer Block von einem anderen Miner) eintrifft, muss ein neuer Block-Header erstellt werden, und es wäre natürlich, die Nonce in diesem Fall bei Null neu zu starten. Um eine Nonce zu erhalten, die "kein Vielfaches von 256" ist, muss es 2^24Hashes vervollständigen, bevor es neu gestartet wird.

Natürlich ist x86 die am weitesten verbreitete Desktop-CPU und Little-Endian, aber das meiste Scrypt-Mining wird auf GPUs durchgeführt. Ich gehe davon aus, dass die Mehrheit dieser GPUs Big-Endian sind oder dass zumindest einige gängige Mining-Software sie veranlasst, ihre Nonce auf Big-Endian-Weise zu erhöhen. Weiß jemand, ob dies der Fall ist?

Aus diesem Diagramm sieht es so aus, als könnten moderne GPUs Scrypt mit ungefähr 1 Mhash/Sek. ausführen. Hashes würden also 2^2416 Sekunden dauern. Litecoin verzeichnet derzeit durchschnittlich etwa 10.000 Transaktionen pro Tag, was im Durchschnitt alle 8 Sekunden eine Transaktion ist. Es wäre also nicht verwunderlich, dass ein Miner vor dem Neustart normalerweise nicht in sein High-Byte (das für Sie das Low-Byte ist) gelangt.

Diese Hypothese würde auch erklären, warum wir bei Bitcoin kein solches Muster sehen. Aktuelle SHA-256-ASIC-Miner laufen mit vielen Ghash/Sek. und durchlaufen daher sehr wahrscheinlich alle 2^32möglichen Nonces, bevor sie durch neue Transaktionsdaten neu gestartet werden. (Möglicherweise sehen wir jedoch Muster im extraNonce.)

Ich habe die folgenden Tests mit C# durchgeführt (unter Verwendung des Block-Headers aus dem Litecoin-Wiki ; Dogecoin ist das gleiche Geschäft). Hier ist ein Test mit scrypt: (Ich habe das Limit nicht auf 14857 voreingestellt; es hat nur so lange gedauert, dass ich es dort gestoppt habe)

var dict = new Dictionary<uint, int> { { 0, 0 }, { 1, 0 } };
byte[] blockHeader = new byte[] { 0x01, 0x00, 0x00, 0x00, 0xae, 0x17, 0x89, 0x34, 0x85, 0x1b, 0xfa, 0x0e, 0x83, 0xcc, 0xb6, 0xa3, 0xfc, 0x4b, 0xfd, 0xdf, 0xf3, 0x64, 0x1e, 0x10, 0x4b, 0x6c, 0x46, 0x80, 0xc3, 0x15, 0x09, 0x07, 0x4e, 0x69, 0x9b, 0xe2, 0xbd, 0x67, 0x2d, 0x8d, 0x21, 0x99, 0xef, 0x37, 0xa5, 0x96, 0x78, 0xf9, 0x24, 0x43, 0x08, 0x3e, 0x3b, 0x85, 0xed, 0xef, 0x8b, 0x45, 0xc7, 0x17, 0x59, 0x37, 0x1f, 0x82, 0x3b, 0xab, 0x59, 0xa9, 0x71, 0x26, 0x61, 0x4f, 0x44, 0xd5, 0x00, 0x1d, 0x45, 0x92, 0x01, 0x80, };
for (uint nonce = 0; nonce < 14857; nonce++)
{
    var nonceBytes = BitConverter.GetBytes(nonce);
    Array.Copy(nonceBytes, 0, blockHeader, blockHeader.Length - 4, 4);
    var hash = SCrypt.ComputeDerivedKey(blockHeader, blockHeader, 1024, 1, 1, null, 32);
    if (hash[31] == 0)
        dict[nonce % 2] += 1;
}

Ergebnisse:

0 32
1 29

Und mit SHA256 (unter Verwendung des Blockheaders aus dem Bitcoin-Wiki )

var sha = SHA256.Create();
var dict = new Dictionary<uint, int> { { 0, 0 }, { 1, 0 } };
byte[] blockHeader = new byte[] {0x01,0x00,0x00,0x00,
    0x81,0xcd,0x02,0xab,0x7e,0x56,0x9e,0x8b,0xcd,0x93,0x17,0xe2,0xfe,0x99,0xf2,0xde,0x44,0xd4,0x9a,0xb2,0xb8,0x85,0x1b,0xa4,0xa3,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
    0xe3,0x20,0xb6,0xc2,0xff,0xfc,0x8d,0x75,0x04,0x23,0xdb,0x8b,0x1e,0xb9,0x42,0xae,0x71,0x0e,0x95,0x1e,0xd7,0x97,0xf7,0xaf,0xfc,0x88,0x92,0xb0,0xf1,0xfc,0x12,0x2b,
    0xc7,0xf5,0xd7,0x4d,
    0xf2,0xb9,0x44,0x1a,
    0x42,0xa1,0x46,0x95,};
for (uint nonce = 0; nonce < 1000000; nonce++)
{
    var nonceBytes = BitConverter.GetBytes(nonce);
    Array.Copy(nonceBytes, 0, blockHeader, blockHeader.Length - 4, 4);
    var hash = sha.ComputeHash(sha.ComputeHash(blockHeader));
    if (hash[0] == 1)
        dict[nonce % 2] += 1;
}

Die Ergebnisse:

0 1908 
1 1951 

Dies zeigt, dass Münzalgorithmen unabhängig davon, ob die Nonce gerade ist, ungefähr die gleiche Anzahl von Ergebnissen mit hohem Schwierigkeitsgrad erzeugen. (Ich glaube, dies ist ein guter Test sowohl für SHA256-Münzen wie Bitcoin als auch für verschlüsselte Münzen wie Litecoin und Dogecoin; ja, ich tue so, als wäre die Schwierigkeit viel geringer, indem ich nur auf ein Byte achte, aber der Punkt bleibt)

Warum also sind Vielfache von 256 und gerade Zahlen in der realen Welt so verbreitet? Meine Vermutung ist, dass Mining-Software am häufigsten diese Nonces auswählt, obwohl sie keinen Vorteil haben. Was Sie zum Beispiel eine Nonce nennen, die durch 256 teilbar ist, könnte als Zahl unter 2^24 betrachtet werden (mit umgekehrter Endianness). Nonces müssen nicht mit hoher Entropie ausgewählt werden, daher ist es akzeptabel, dass sie etwas vorhersehbar sind - solange Sie nicht Ihre Zeit verschwenden, indem Sie dieselbe Nonce zweimal für denselben Blockheader verwenden.

Die Endianness ist möglicherweise kein Problem, da sie entweder in Big oder Little Endian eine Möglichkeit bietet, die Möglichkeit zu erhöhen, die Nonce schnell zu finden, im Vergleich zu anderen, die nur nacheinander über 2 ^ 32-mal iterieren.

In Little Endian bedeutet das Ergebnis, dass > 80 % der Nonces ein Vielfaches von 256 sind, sodass Sie möglicherweise auch 80 % bis 90 % der Möglichkeiten haben, die Nonce zu finden, die den Block lösen kann.

Da die Nonce nicht vorhersehbar ist, sollte es kein Problem sein, die Nonce von 0 aufwärts in Big Endian oder Little Endian zu zählen. Sie konnten immer eine mögliche Lösung für den Block finden.