Ich habe ein Problem damit, herauszufinden, wie Miner das folgende Problem lösen:
Nehmen wir an, wir haben 2 Miner: M1, M2.
M1 fügt die Transaktionen A, B, C, D zu ihrem Block hinzu. M2 fügt die Transaktionen A, B, C zu ihrem Block hinzu. Aus irgendeinem Grund wird Transaktion D einige Sekunden, nachdem M1 sie erhalten hat, an M2 gesendet.
Jetzt löst M2 den Block und sendet diesen Block an alle. Folglich wirft M1 seinen Block weg und beginnt mit der Arbeit an einem neuen Block.
Als nächstes fügt M1 die Transaktionen E,F,G zu ihrem Block hinzu, während M2 D,E,F,G (M2 bekommt jetzt D) zu ihrem Block hinzufügt. Jetzt löst M1 zuerst den Block und sendet ihn. Daher wirft M2 seinen Block weg und beginnt einen neuen.
In diesem Fall kommt Transaktion D in keinen Block! (Das Problem wird durch die Netzwerkgeschwindigkeit verursacht, die dazu führte, dass D einige Sekunden nach M1 bei M2 ankam.)
Also, wie wird dieses Problem behandelt oder vermieden?
Miner haben Mempools, in denen sie alle Transaktionen speichern, die sie in zukünftige Blöcke aufnehmen möchten. Sie legen Transaktionen, die sie erhalten haben, nicht sofort in ihre Blöcke.
Aber sie fügen sie auch nicht sofort in ihren Mempool ein. Die Transaktionen im Mempool jedes Miners sind gültig und den Aufwand des Miners wert (mindestens eine bestimmte Gebühr zahlen).
Sie können im Moment nicht einmal alle ihnen bekannten Transaktionen in ihre Blöcke aufnehmen. Blöcke können höchstens 1 MB groß sein und da es derzeit viele Transaktionen gibt, sind die Mempools der Miner viel größer als 1 MB.
Zum Zeitpunkt 0 sehen die Mempools so aus:
mem_M1 = {A, B, C, D}
mem_M2 = {A, B, C}
Wenn M2 den Block löst, entfernen sie alle Transaktionen, die sie in ihren Block aufgenommen haben, aus ihrem Mempool:
mem_M1 = {A, B, C, D}
mem_M2 = {}
M2 sendet dann den Block an M1, der den neu empfangenen Block validiert. Wenn M1 den Block für gültig hält, entfernen sie alle Transaktionen in diesem Block aus ihrem Mempool:
mem_M1 = {D}
mem_M2 = {}
Beachten Sie, dass D immer noch da ist. M1 leert ihren Mempool nicht. Nur die in den neu empfangenen Blöcken enthaltenen Transaktionen wurden entfernt.
Sie erhalten dann weitere Transaktionen:
mem_M1 = {D, E, F, G}
mem_M2 = {D, E, F, G}
Als nächstes löst M1 einen Block und entfernt die darin enthaltenen Transaktionen aus ihrem Mempool:
mem_M1 = {}
mem_M2 = {D, E, F, G}
Nachdem M1 seinen neu geschürften Block an M2 gesendet hat, entfernt M2 alle in diesem Block enthaltenen Transaktionen aus seinem Mempool:
mem_M1 = {}
mem_M2 = {}
Alle Transaktionen wurden in Blöcken zusammengefasst.
Der Sender wird erneut übertragen.
Zu Ihrer Information:
"obwohl Transaktionen irgendwann vergessen werden, wenn sie nicht nach einer Weile in einen Block geraten. Der Sender und der Empfänger der Transaktion werden jedoch erneut gesendet."