Q29zYSBzb25vIE1lbXBvb2xzIGUgY29tZSBmdW56aW9uYW5vPw==

<p><img src="https://gimg2.gateimg.com/blog/167999845218246089620230328-181352.jpeg" alt=""></p>
<h2 id="h2-TL20DR309"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La funzione principale di mempool è quella di archiviare le transazioni prima che vengano convalidate.</p>
<p>Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sono esempi di blockchain che utilizzano mempools.</p>
<p>La congestione della blockchain è il motivo principale per cui le transazioni rimangono bloccate per molto tempo.</p>
<p>Se desideri che una transazione venga effettuata rapidamente, utilizza commissioni di gas adeguate.</p>
<h2 id="h2-Introduzione30131"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Spesso effettuiamo transazioni su varie blockchain come <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">Ethereum</a> e Bitcoin, ma potremmo non comprendere appieno alcune delle loro tecniche. Tuttavia, conoscere come alcuni componenti delle blockchains lavorano può aiutarci ad accelerare le nostre transazioni o a ridurre i loro costi.</p>
<p>In questa analisi discutiamo di Mempool nella blockchain e di come funziona. Spiegheremo anche come gestire le transazioni in sospeso o ritardate sulle reti <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ethereum.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-a-blockchain-explorer/355" target="_blank">Cos’è un esploratore di blockchain?</a></p>
<h2 id="h2-Cos20un20Mempool276721"><a name="Cos’è un Mempool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un Mempool?</h2><p>Mempool, <a href="https://www.gate.io/learn/articles/what-is-the-bitcoin-mempool/132" target="_blank">una forma abbreviata di pool di memoria</a>, è uno spazio di nodo per memorizzare informazioni come transazioni non confermate. Funziona come una sala d’attesa per le transazioni che non sono ancora state confermate o approvate. Ricorda che le transazioni vengono incluse in un blocco solo quando sono verificate o approvate.</p>
<p>In altre parole, un mempool è uno spazio in cui le transazioni in sospeso attendono prima di essere aggiunte a un blocco.</p>
<p>Quando la transazione viene verificata, significa che tutti i partecipanti sulla blockchain possono accedere alle informazioni. Tuttavia, prima che la transazione venga approvata, vari nodi verificano la firma, controllano se l’output non è maggiore dell’input e che il sistema non abbia ancora inviato gli asset digitali. Se una di queste condizioni non viene soddisfatta, i validatori o i miner rifiutano la transazione.</p>
<p>È importante capire che non esiste una singola mempool per una blockchain. Pertanto, ogni nodo sulla rete blockchain ha la propria mempool, anche chiamata transazione pool. Di conseguenza, le mempool dei vari nodi costituiscono una mempool collettiva della blockchain.</p>
<p>Come esempio, le transazioni che vengono effettuate sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le transazioni di rete non vengono aggiunte direttamente alla blockchain. Ogni nodo memorizza le transazioni in una memoria temporanea chiamata mempool o txpool. Di conseguenza, si forma una coda che deve essere controllata e convalidata.</p>
<p>Quindi, possiamo definire semplicemente una mempool come una coda organizzata di transazioni che devono essere ordinate e aggiunte a un blocco.<br><img src="https://gimg2.gateimg.com/image/article/16904392835391690438914_.pic.jpg" alt=""><br>Pool di memoria (Mempool) in un nodo- Babypips</p>
<p>Ricorda che le transazioni esistono solo in una mempool prima che siano confermate o inserite in blocchi. Nel diagramma sopra, la sezione di colore blu è lo spazio mempool che esiste all’interno di un nodo. Il diagramma successivo mostra la distribuzione delle mempool in una rete.<br><img src="https://gimg2.gateimg.com/image/article/16904393035401690438943_.pic.jpg" alt=""><br>I nodi completi nella rete Bitcoin hanno Mempools - Babypips</p>
<p>Come si vede nella figura sopra, ogni nodo completo in una rete come Bitcoin o <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha una mempool. Tuttavia, ogni transazione verrà trasmessa ai nodi di rete come indicato nel diagramma successivo.<br><img src="https://gimg2.gateimg.com/image/article/16904393285411690438955_.pic.jpg" alt=""><br>Una rete di nodi Bitcoin - Babypips</p>
<p>Come notiamo nel diagramma, l’utente in viola avvia una transazione bitcoin che viene memorizzata nel mempool prima dell’approvazione. È essenziale notare che una volta verificata la transazione, viene aggiunta a un blocco come mostra la prossima illustrazione.<br><img src="https://gimg2.gateimg.com/image/article/16904393545421690438966_.pic.jpg" alt=""><br>Una transazione viene aggiunta al file (blocco) - Babypips</p>
<p>La freccia blu nel diagramma mostra cosa succede quando una transazione viene verificata, viene spostata dalla txpool a un blocco. In quella fase tutti i computer avranno il file aggiornato della transazione confermata.</p>
<h2 id="h2-Come20funzionano20le20Mempools473675"><a name="Come funzionano le Mempools" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funzionano le Mempools</h2><p>In generale, i Mempools non funzionano esattamente allo stesso modo. Come operano dipende dall’architettura di ogni blockchain. In altre parole, funzionano in modo diverso a seconda dei tipi di meccanismi di consenso delle reti. Le transazioni vengono verificate dai validatori o dai minatori a seconda delle reti.</p>
<p>Ad esempio, le transazioni sulla blockchain di bitcoin sono verificate dai minatori poiché utilizza il meccanismo di consenso proof-of-work. D’altra parte, le transazioni sulla rete Ethereum sono approvate dai validatori perché la blockchain utilizza il meccanismo di consenso proof-of-stake.</p>
<p>Leggi anche: <a href="https://www.gate.io/de/blog_detail/2793/eigenlayer-protocol-reshaping-ethereum-and-potential-network-health-concerns" target="_blank">Ridefinire Ethereum e potenziali preoccupazioni per la salute della rete</a></p>
<p>La rete bitcoin richiede un minimo di sei conferme per transazione, mentre la blockchain di Ethereum ne richiede almeno sette. Fondamentalmente, ogni transazione in un mempool ha uno stato specifico. È in attesa o in coda. Quando un validatore o minatore convalida una transazione in coda, diventa in attesa.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-the-bitcoin-lightning-network/109" target="_blank">Cos’è la rete Lightning di Bitcoin?</a></p>
<p>Diamo un’occhiata a un semplice esempio di ciò che accade quando invii ETH a un amico. La procedura prevede l’inserimento dell’indirizzo del portafoglio, la configurazione della commissione di gas e <a href="https://www.gate.io/fr/blog_detail/2905/a-comprehensive-guide-on-verifying-ethereum-transactions" target="_blank">conferma della transazione</a>.</p>
<p>Una volta eseguite queste operazioni, la tua transazione viene messa in coda in attesa di verifica. A quel punto viene trasmessa a tutta la rete dei nodi, ma non fa ancora parte di alcun blocco.</p>
<p>Se i validatori controllano la transazione e trovano che soddisfa tutte le condizioni, viene spostata dallo stato di coda allo stato di attesa, in attesa di conferma. Da lì, uno dei validatori prende la transazione dal mempool e la aggiunge a un nuovo blocco.</p>
<p>A quel punto diversi validatori lo approvano, consentendo così al tuo amico di ricevere gli ETH.</p>
<h2 id="h2-Riassumiamo20la20dinamica20del20mempool541097"><a name="Riassumiamo la dinamica del mempool" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassumiamo la dinamica del mempool</h2><p>Passaggio 1: Il mittente inserisce l’indirizzo di destinazione, accetta le commissioni di transazione di rete e fa clic su ‘INVIA’</p>
<p>PASSAGGIO 2: La transazione viene aggiunta al mempool più vicino e messa in coda.</p>
<p>PASSAGGIO 3: I dati del mempool vengono diffusi agli altri nodi nella rete.</p>
<p>PASSAGGIO 4: Un nodo approva la transazione e il suo stato passa da In coda a In sospeso.</p>
<p>PASSO 5: Un minatore sceglie la transazione in sospeso e la aggiunge a un blocco.</p>
<p>PASSAGGIO 6: Il resto dei nodi elimina la transazione dalla loro mempool.</p>
<p>PASSO 7: La transazione è completata e l’asset arriva nel portafoglio di destinazione.</p>
<p>Ora che comprendi cosa ritarda la tua transazione quando la elabori, vediamo le ragioni per cui alcune transazioni rimangono bloccate e quali azioni puoi intraprendere.</p>
<h2 id="h2-Motivi20per20cui20la20transazione2020bloccata20nel20Mempool729473"><a name="Motivi per cui la transazione è bloccata nel Mempool" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per cui la transazione è bloccata nel Mempool</h2><p>Il motivo principale per cui le transazioni sono bloccate nel mempool è la congestione di rete. Quando c’è una elevata pressione sul volume delle transazioni, aumenta lo spazio disponibile per i blocchi, il che attiva il ritardo del mempool. Ciò si verifica se il numero di transazioni in sospeso è superiore alla media delle transazioni in un blocco.</p>
<p>Alcuni eventi e notizie che influenzano il livello di traffico sulla blockchain possono causare congestione nella rete. Ad esempio, gli airdrop, l’elenco su più exchange o nuove partnership possono portare alla congestione. Tuttavia, ci sono fattori che consentono ai nodi di dare priorità a determinate transazioni.</p>
<p><strong>Commissione di transazione</strong>: La quantità di commissioni associate alle diverse transazioni determina quelle che vengono approvate per prime. Poiché i minatori e i validatori sono motivati dal profitto, danno priorità alle transazioni con commissioni più alte perché ciò consente loro di ottenere ricompense più elevate.</p>
<p>Pertanto, i minatori e i validatori organizzano la transazione nei loro mempool in base alle commissioni per unità, come ad esempio satoshi/byte. Alla fine, aggiungono ai blocchi le transazioni con le commissioni più alte per prime. Questo sistema costringe gli utenti a impostare commissioni elevate per le loro transazioni.</p>
<p>Tuttavia, a seconda del traffico di rete, gli utenti possono impostare commissioni di gas ottimali e comunque far confermare le loro transazioni in tempo. Ciò che è importante per gli utenti è controllare fattori come dati storici, congestione di rete, volume di transazioni e distribuzione delle commissioni nella mempool prima di impostare le proprie commissioni di gas.</p>
<p><strong>Tempi di conferma</strong>: Gli utenti potrebbero anche aver bisogno di controllare i tempi di conferma prima di impostare le loro commissioni. Quando i tempi di conferma sono elevati, significa che i minatori e i validatori danno la precedenza alle transazioni con commissioni elevate. In sostanza, quando il mempool è congestionato, significa che le transazioni con commissioni inferiori impiegheranno molto tempo per essere elaborate.</p>
<p><strong>Spazio di blocco</strong>: Lo spazio del blocco determina anche la quantità di tempo che trascorre prima che le transazioni vengano approvate. Poiché lo spazio del blocco è sempre limitato, i minatori e i validatori danno la precedenza alle transazioni con commissioni più alte. Ciò significa che le transazioni con commissioni più basse trascorrono molto tempo nel mempool.</p>
<p><strong>Dimensione del mempool ed evizione</strong>: Ogni transazione da aggiungere al blocco è un pezzo di dati con una dimensione misurata in kilobyte. Pertanto, i mempool di grandi dimensioni possono ospitare molte transazioni. Di solito, i nodi impostano le dimensioni dei loro mempool, che sono spesso di 300 MB per Bitcoin. Quando un mempool raggiunge una soglia, il nodo può impostare una commissione di transazione minima.</p>
<p>Quando gli utenti comprendono tali dinamiche, diventa facile per loro impostare le commissioni di transazione e farle approvare entro un periodo ragionevole. Ad esempio, possono evitare di pagare troppo durante periodi di bassa capacità o pagare troppo poco durante i momenti di picco quando hanno transazioni sensibili al tempo. Possono anche fare previsioni istruite quasi corrette su quanto rapidamente le loro transazioni verranno convalidate.</p>
<h2 id="h2-Perch20le20transazioni20rimangono20bloccate20nel20Mempool304961"><a name="Perché le transazioni rimangono bloccate nel Mempool" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché le transazioni rimangono bloccate nel Mempool</h2><p>Spesso le transazioni rimangono bloccate nel mempool per diverse ragioni, ma la maggior parte di esse sono legate alle commissioni di gas. Tuttavia, la principale ragione per cui alcune transazioni rimangono bloccate nel mempool è la congestione di rete. Quando c’è congestione, le transazioni con commissioni elevate passano per prime lasciando le altre bloccate lì.</p>
<p>Pertanto, la cosa migliore da fare durante i periodi di picco di rete è aumentare le commissioni di transazione. Questo perché quando c’è congestione le commissioni di gas aumentano. Quindi, se elabori una transazione durante i periodi di grande affluenza, dovresti abbinare le tue commissioni a quelle che pagano gli altri utenti della rete.</p>
<p>L’altro motivo per cui le transazioni sono bloccate nel mempool è una diminuzione del tasso di hash. Diciamo che il tasso di hash è diminuito quando la rete non ha la potenza di calcolo fisica per eseguire un elevato numero di transazioni in sospeso.</p>
<h2 id="h2-Come20rilasciare20la20tua20transazione20dal20Mempool776958"><a name="Come rilasciare la tua transazione dal Mempool" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come rilasciare la tua transazione dal Mempool</h2><p>Hai alcune opzioni quando la tua transazione è bloccata nella mempool. La prima opzione è annullare la transazione. In questo caso, ti costerà un’altra commissione di transazione. Ad esempio, puoi inviare nuovamente la transazione con lo stesso nonce.</p>
<p>In secondo luogo, puoi scegliere di accelerare la transazione collegando il tuo Ledger a un portafoglio di terze parti come MetaMask o Electrum. Tuttavia, dovrai pagare di più per questo.</p>
<p>La terza opzione è aspettare un po’ più a lungo affinché la transazione vada a buon fine. Facendo ciò, si attende che il traffico di rete diminuisca, il che permetterà alla tua transazione di andare a buon fine senza costi aggiuntivi.</p>
<h3 id="h3-Mempool20in20Bitcoin137816"><a name="Mempool in Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mempool in Bitcoin</h3><p>Le transazioni inviate alla rete Bitcoin non vengono aggiunte istantaneamente alla blockchain. Prima vengono inserite nella mempool. In passato, tali transazioni richiedevano solo commissioni misurate in satoshi per byte.</p>
<p>Tuttavia, ciò è cambiato dopo l’aggiornamento SegWit che consente di misurare le transazioni in unità di peso. La cosa positiva è che le funzionalità SegWit consentono di aggiungere più dati a un blocco rispetto a prima. In particolare, ci sono 2 MB di dati per blocco, anche se può aumentare a 4 MB.</p>
<h3 id="h3-Mempool20di20Ethereum191600"><a name="Mempool di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mempool di Ethereum</h3><p>Inizialmente, la rete Ethereum richiedeva che le transazioni entrassero nella mempool prima di essere convalidate. Tuttavia, quando la blockchain è passata dal meccanismo di consenso proof-of-work a quello proof-of-stake, ha introdotto il concetto di block-builder.</p>
<p>Fondamentalmente, i costruttori di blocchi sono attori terzi che compilano le transazioni in un pacchetto di transazioni ottimizzato che forma un blocco. In questo caso, le entità terze compilano o riordinano determinate transazioni da una mempool in pacchetti. Da lì, offrono i pacchetti di transazioni ai validatori per l’inclusione nei blocchi. Le entità terze ottengono ricompense per svolgere queste attività.</p>
<h2 id="h2-Conclusion605152"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>In sintesi, un mempool è uno spazio in cui un nodo blockchain memorizza temporaneamente le transazioni prima che vengano validate. La durata di una transazione nel mempool in Ethereum dipende da diversi fattori come la congestione del traffico di rete e la commissione gas. Sia Bitcoin che Ethereum utilizzano pool di transazioni.</p>
<h2 id="h2-Domande20frequenti20sui20Mempools253332"><a name="Domande frequenti sui Mempools" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sui Mempools</h2><h3 id="h3-Cos20il20mempool418292"><a name="Cos’è il mempool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il mempool?</h3><p>Un mempool è uno spazio in cui le transazioni in sospeso attendono prima di essere aggiunte a un blocco. Una volta che la transazione è convalidata, viene aggiunta a un blocco che esiste sulla blockchain.</p>
<h3 id="h3-Cosa20succede20nel20mempool159209"><a name="Cosa succede nel mempool?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succede nel mempool?</h3><p>Quando alcune transazioni si trovano in un mempool, alcuni validatori o minatori le selezionano e le aggiungono ai blocchi. Tuttavia, alcune delle transazioni possono rimanere in coda o in sospeso per un lungo periodo se c’è congestione del traffico di rete.</p>
<h3 id="h3-Cos20un20Mempool20BTC297383"><a name="Cos’è un Mempool BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un Mempool BTC?</h3><p>Il mempool BTC è la sala d’attesa per le transazioni che vengono elaborate sulla rete Bitcoin. Di solito, ogni nodo della blockchain di Bitcoin ha il proprio mempool.</p>
<h3 id="h3-Cosa2020Mempool20in20Ethereum209805"><a name="Cosa è Mempool in Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è Mempool in Ethereum?</h3><p>Un mempool in Ethereum è lo spazio per memorizzare le transazioni sui nodi Ethereum prima che vengano confermate. Il tempo che trascorre prima che queste transazioni vengano confermate dipende dal traffico della rete Ethereum entro un certo periodo.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>