Propagarea tranzacției nu se oprește: lipsesc nodurile care au văzut-o
Fiecare nod retrimite tranzacția tuturor vecinilor, inclusiv celor care o au deja, iar într-o rețea cu cicluri mesajele circulă la nesfârșit. Ține un set cu nodurile care au văzut tranzacția și trimite-o mai departe doar dacă e nouă pentru vecin.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Nu primești o eroare Python, ci o buclă care nu se termină (în editor: limita de timp) sau un număr uriaș de mesaje. Rețelele P2P au cicluri: A e vecin cu B, B cu C, C din nou cu A. Dacă fiecare nod retrimite tot ce primește, tranzacția se întoarce mereu la nodurile care o au deja, iar coada de mesaje crește continuu.
Nodurile reale (Bitcoin, Ethereum) rezolvă asta exact cum o rezolvă algoritmul de parcurgere în lățime (BFS): fiecare nod ține minte ce tranzacții a văzut deja, după txid, și ignoră duplicatele. Așa fiecare nod primește tranzacția și o retrimite o singură dată. Numărul de mesaje devine finit și ușor de calculat: fiecare nod trimite câte un mesaj fiecărui vecin, o dată.
De ce apare: cauzele frecvente
1Fără evidența nodurilor vizitate
while coada:
nod = coada.popleft()
for v in vecini[nod]:
coada.append(v)vazut = {start}
while coada:
nod = coada.popleft()
for v in vecini[nod]:
if v not in vazut:
vazut.add(v)
coada.append(v)Un nod intră în coadă o singură dată, deci bucla se termină.
2Nodul marcat abia când îl scoți din coadă
while coada:
nod = coada.popleft()
vazut.add(nod)
for v in vecini[nod]:
if v not in vazut:
coada.append(v)while coada:
nod = coada.popleft()
for v in vecini[nod]:
if v not in vazut:
vazut.add(v)
coada.append(v)Dacă marchezi la scoatere, același nod poate intra în coadă de mai multe ori până ajunge să fie procesat.
Repară eroarea, direct în pagină
Simularea de mai jos propagă o tranzacție de la nodul A prin rețea, dar nodurile o retrimit și vecinilor care au primit-o deja, așa că se oprește doar la limita de siguranță de 1000 de mesaje. Repară bucla ca fiecare nod să fie pus în coadă o singură dată, iar programul să afișeze Noduri care au primit: 6 și Mesaje trimise: 16.
from collections import deque
vecini = {
"A": ["B", "C"],
"B": ["A", "C", "D"],
"C": ["A", "B", "E"],
"D": ["B", "E", "F"],
"E": ["C", "D", "F"],
"F": ["D", "E"],
}
primit = {"A"}
coada = deque(["A"])
mesaje = 0
while coada and mesaje < 1000:
nod = coada.popleft()
for v in vecini[nod]:
mesaje += 1
primit.add(v)
coada.append(v)
print("Noduri care au primit:", len(primit))
print("Mesaje trimise:", mesaje)Noduri care au primit: 6 Mesaje trimise: 16
Indiciu
Pune un vecin în coadă doar dacă nu a primit deja tranzacția.
Reparația
from collections import deque
vecini = {
"A": ["B", "C"],
"B": ["A", "C", "D"],
"C": ["A", "B", "E"],
"D": ["B", "E", "F"],
"E": ["C", "D", "F"],
"F": ["D", "E"],
}
primit = {"A"}
coada = deque(["A"])
mesaje = 0
while coada and mesaje < 1000:
nod = coada.popleft()
for v in vecini[nod]:
mesaje += 1
if v not in primit:
primit.add(v)
coada.append(v)
print("Noduri care au primit:", len(primit))
print("Mesaje trimise:", mesaje)De ce merge
Fără verificare, fiecare mesaj punea vecinul înapoi în coadă, chiar dacă avea deja tranzacția, iar ciclurile rețelei țineau coada mereu plină. Cu if v not in primit, un nod intră în coadă o singură dată și retrimite o singură dată. Mesajele sunt câte unul pe fiecare capăt al fiecărei legături: 8 legături, deci 16 mesaje.
Cum o eviți pe viitor
Orice parcurgere a unei rețele (propagare, căutarea celui mai scurt drum, numărarea nodurilor) are nevoie de un set vazut, actualizat când nodul intră în coadă. În simulări, pune o limită de siguranță (număr maxim de pași) cât testezi, ca o greșeală să nu blocheze programul. În nodurile reale, evidența se ține după txid, în mempool.
Întrebări frecvente
De ce în editor apare limita de timp?
Bucla nu se termină niciodată, iar editorul oprește programul după câteva secunde. Limita de siguranță din exercițiu (1000 de mesaje) face ca greșeala să se vadă ca un număr, nu ca o oprire.
Câte mesaje trimite o propagare corectă?
Fiecare nod care primește tranzacția o trimite tuturor vecinilor o dată, deci în total de două ori numărul de legături din rețea, dacă toate nodurile sunt conectate.
Erori înrudite
TypeError: 'set' object is not subscriptable Ai încercat să iei un element dintr-un set după poziție, de exemplu vecini["A"][0]. Seturile nu au ordine și nici indici: transformă-l într-o listă sortată, sorted(vecini["A"])[0], sau parcurge-l cu for. IndexError: pop from empty list Ai apelat pop() pe o listă goală, de obicei când iei tranzacții din mempool pentru un bloc și mempool-ul se golește înainte să se umple blocul. Verifică lista în condiția buclei: while mempool and len(bloc) < MAX. RuntimeError: dictionary changed size during iteration Ai șters (sau adăugat) chei într-un dicționar în timp ce îl parcurgeai cu for, de obicei UTXO-urile cheltuite din setul UTXO. Parcurge o copie (list(utxo)) sau construiește un dicționar nou. Învață Blockchain de la zero, cu exerciții la fiecare lecție
Curs Blockchain și criptomonede: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
