VW5hIGd1aWRhIGNvbXBsZXRhIHN1bGxhIHZlcmlmaWNhIGRlbGxlIHRyYW5zYXppb25pIEV0aGVyZXVt

<p><img src="https://gimg2.gateimg.com/image/article/1689556157JMHBZN.jpeg" alt=""></p>
<h2 id="h2-TL20DR197644"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Le transazioni sono messaggi di dati che sono firmati criptograficamente.</p>
<p><a href="https://www.gate.io/learn/articles/what-is-etherscan/329" target="_blank">Etherscan</a>, Ethplorer e EthVM sono esempi dei più popolari <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> esploratori di blockchain.</p>
<p>Di solito, la transazione <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> richiede 15 minuti e 5 secondi per completarsi.</p>
<h2 id="h2-Introduzione986483"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Attualmente, sul mercato ci sono migliaia di blockchain che servono a scopi diversi. Nonostante un così alto numero di blockchain, non c’è dubbio che un giorno avrai bisogno di effettuare transazioni sulla rete Ethereum. Questo potrebbe richiedere di verificare lo stato della tua transazione utilizzando l’esploratore di blockchain Ethereum di tua scelta.</p>
<p>Oggi, discutiamo di come verificare le transazioni sulla rete ETH. Esploreremo anche i diversi tipi di transazioni che le persone e i contratti intelligenti eseguono sulla rete Ethereum.</p>
<h2 id="h2-Cos20la20rete20ETH620333"><a name="Cos’è la rete ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la rete ETH?</h2><p>Molte persone utilizzano la rete Ethereum, chiamata anche rete ETH, perché ospita molte blockchain e applicazioni decentralizzate. Fondamentalmente, la blockchain di Ethereum, fondata da <a href="https://www.gate.io/blog_detail/2345/vitalik-buterin-endorses-nft-collection-pumps-value-opensea" target="_blank">Vitalik Buterin</a> e Gavin Wood nel 2015, è una delle reti più grandi. In termini di capitalizzazione di mercato, è la seconda rete più grande dal momento che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è la blockchain classificata al primo posto.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-ethereum-2-0/102" target="_blank">Cos’è Ethereum 2.0? Comprendere La Fusione</a></p>
<p>Fondamentalmente, Ethereum è una piattaforma decentralizzata che ospita molte applicazioni che svolgono diverse funzioni come il gioco e il SocialFi, tra gli altri. Inoltre, ci sono molte applicazioni finanziarie decentralizzate che esistono su di essa. Tutte queste applicazioni e blockchain che il protocollo Ethereum ospita utilizzano la rete ETH per funzionare.</p>
<p>In parole semplici, una blockchain è un registro pubblico distribuito che supporta varie transazioni. È distribuito perché ogni computer o nodo connesso ad esso detiene una copia identica delle transazioni che vi si svolgono.</p>
<p>D’altra parte, è decentralizzato perché non c’è un’unica entità o autorità che lo controlla. Tutti i nodi collegati ad esso partecipano alla sua gestione. Ad esempio, alcuni di questi nodi verificano le transazioni che avvengono sulla blockchain.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">Come comprare Ethereum su Gate.io</a></p>
<h2 id="h2-Cosa20sono20le20transazioni346257"><a name="Cosa sono le transazioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono le transazioni?</h2><p>Come spiegato in precedenza, varie transazioni avvengono sulla rete Ethereum. Le transazioni sono messaggi di dati che vengono firmati criptograficamente. Questi messaggi contengono alcune istruzioni specifiche. I contratti intelligenti utilizzano tali istruzioni per eseguire determinate transazioni come l’invio di monete Ether da un indirizzo del portafoglio a un altro. Inoltre, questi messaggi consentono agli utenti di tutto il mondo di interagire tra loro.</p>
<p>Ogni volta che una rete invia un insieme di istruzioni o transazioni, lo stato della blockchain cambia. Il tipo più semplice di transazione coinvolge il trasferimento di monete o token tra due account.</p>
<h2 id="h2-Tipi20di20transazioni20e20loro20dettagli286482"><a name="Tipi di transazioni e loro dettagli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tipi di transazioni e loro dettagli</h2><p>Ci sono diversi tipi di transazioni che includono transazioni regolari, transazioni di esecuzione del contratto e transazioni di distribuzione del contratto.</p>
<p><strong>Transazioni regolari</strong>: Una transazione regolare, anche chiamata transazione normale, si verifica quando un indirizzo di portafoglio di proprietà esterna (indirizzo del portafoglio) invia alcuni token o monete a un altro indirizzo di portafoglio di proprietà esterna (EOA). Su Etherscan, <a href="https://www.gate.io/learn/articles/what-is-etherscan-and-how-to-use-it/380" target="_blank">uno dei popolari esploratori della blockchain di Ethereum</a>, tale transazione viene visualizzata nella scheda Transazione.</p>
<p><strong>Transazione di esecuzione del contratto</strong> Questo avviene quando due parti contraenti concordano sulle condizioni del contratto. In altre parole, comporta il rispetto delle condizioni del contratto entro il periodo di tempo stabilito.</p>
<p><strong>Transazione di distribuzione del contratto</strong>: Questo comporta la corretta implementazione di un contratto intelligente sulla rete Ethereum. In questo caso, il campo dati viene utilizzato per implementare il codice del contratto intelligente nella blockchain. Vediamo le informazioni incluse in una transazione.</p>
<h2 id="h2-Contenuti20della20transazione254524"><a name="Contenuti della transazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Contenuti della transazione</h2><p><strong>Destinatario</strong>: Questo si riferisce all’indirizzo che riceve la transazione.</p>
<p><strong>Firma</strong>: Questo è ciò che identifica il mittente del messaggio. Quando la chiave privata del mittente firma la transazione, la firma viene generata.</p>
<p><strong>Valore</strong>: È il valore del token o della moneta che viene trasferito tra due account.</p>
<p><strong>Dati</strong>: Questo si riferisce ai dati aggiuntivi utilizzati durante l’esecuzione di una transazione. Un bytecode per un contratto intelligente è un esempio di dati.</p>
<p><strong>Limite di gas</strong>: Si riferisce alle unità esatte che verranno consumate affinché una transazione abbia successo.</p>
<p><strong>Commissione massima di priorità per gas</strong>: Questo si riferisce alle unità di gas richieste per dare priorità a una transazione. Quell’importo va al minatore come mancia.</p>
<p><strong>Commissione Massima Per Gas</strong>: È la quantità massima di gas che l’utente permette di consumare affinché una transazione abbia successo.</p>
<h2 id="h2-Ciclo20di20vita20della20transazione20ETH96710"><a name="Ciclo di vita della transazione ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ciclo di vita della transazione ETH</h2><p>Il ciclo di vita della transazione ETH si riferisce a diversi passaggi intrapresi affinché una transazione abbia successo. In altre parole, si tratta di una serie di eventi che si verificano quando viene inviata una transazione. Innanzitutto, il contratto intelligente genera un hash di transazione.</p>
<p>Una volta che ciò è fatto, la transazione viene trasmessa all’intera rete mentre è all’interno di un pool di altre transazioni. Quindi un minatore la seleziona e la aggiunge al blocco successivo. Una conferma di transazione mostra che è riuscita. Di conseguenza, altri utenti possono visualizzarla sulla blockchain.</p>
<p>Una transazione sulla rete Ethereum ha diversi possibili esiti. Vediamo brevemente alcuni di questi.</p>
<p><strong>In attesa</strong>: una transazione è in sospeso se viene trasmessa ma non è ancora stata convalidata. Se la transazione richiede molto tempo per essere approvata, ciò potrebbe indicare una quantità di gas insufficiente. Pertanto, qualcuno dovrebbe verificare se ha assegnato abbastanza ETH per coprire la commissione di transazione.</p>
<p><strong>In coda</strong>: Lo stato in coda significa che ci sono altre transazioni che devono essere convalidate prima della tua. In altre parole, ci sono altre transazioni in sospeso.</p>
<p><strong>Annullato</strong>: Ciò significa che la transazione non può essere approvata per vari motivi. Questo potrebbe essere dovuto a un valore nullo.<br>Rifiutato: Una transazione può essere rifiutata per diversi motivi, tra cui codice illogico, gas insufficiente o istruzione errata.</p>
<h2 id="h2-Principali20motivi20per20verificare20lo20stato20delle20transazioni624705"><a name="Principali motivi per verificare lo stato delle transazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali motivi per verificare lo stato delle transazioni</h2><p>Ci sono diverse ragioni per le quali un utente potrebbe aver bisogno di controllare lo stato della sua transazione. Ad esempio, un individuo potrebbe voler scoprire il costo di una transazione. Questo perché una transazione può avere successo solo se c’è abbastanza gas.</p>
<p>Se l’individuo ha assegnato una piccola commissione di gas, potrebbe volerci del tempo prima che la transazione venga approvata. Pertanto, se la commissione di gas è bassa, l’individuo potrebbe dover inviare nuovamente la transazione.</p>
<p>Inoltre, un esploratore di blockchain potrebbe diffondere diverse informazioni che gli utenti potrebbero voler conoscere. Ad esempio, potrebbe mostrare il numero di blocchi che sono stati estratti, le commissioni di transazione pagate ai minatori, il prezzo di ETH al momento della estrazione, la tassa di base, il limite di gas massimo allocato all’utente e molto altro. Gli utenti potrebbero utilizzare tali informazioni per garantire che le loro transazioni siano convalidare entro un breve periodo.</p>
<h2 id="h2-Come20verificare20una20transazione20Ethereum788972"><a name="Come verificare una transazione Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come verificare una transazione Ethereum</h2><p><strong>Passaggio 1</strong> quando si desidera verificare lo stato di una transazione Ethereum, il primo passo è <a href="https://www.gate.io/learn/articles/what-is-a-blockchain-explorer/355" target="_blank">seleziona l’esploratore di blockchain</a> vuoi usare. Etherscan, Ethplorer ed EthVM sono esempi di esploratori popolari della blockchain Ethereum.</p>
<p><strong>Passaggio 2</strong>: Inserisci l’hash della transazione nel campo di ricerca. Nota che l’hash della transazione è un identificatore unico per una transazione specifica. Fondamentalmente, l’hash della transazione è una stringa di numeri e lettere casuali.</p>
<p>Alcuni esploratori potrebbero fare riferimento all’hash di transazione come “hash” o “txn hash”. Di solito, il campo di ricerca si trova nella parte superiore dell’esploratore blockchain come indicato nell’immagine seguente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689556684Ethereum 1.png" alt=""><br>Seleziona il miglior esploratore - Cointelegraph</p>
<p>È anche importante notare che puoi cercare i dati desiderati utilizzando il blocco, l’indirizzo del portafoglio o il nome di dominio.<br>Passaggio 3: Una volta inserito l’hash della transazione o qualsiasi altro identificatore, fai clic su “Cerca” che trovi nell’esploratore blockchain. In alternativa, puoi premere Invio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689556701Ethereum 2.png" alt=""><br>Fare clic sul pulsante di ricerca - Cointelegraph</p>
<p><strong>Passaggio 4</strong>: Controlla lo stato della transazione<br>L’esploratore mostrerà lo stato della transazione nel riepilogo della transazione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689557396Ethereum 3.png" alt=""><br>Verifica lo stato della transazione - Cointelegraph</p>
<p>Come si nota dall’immagine, vengono visualizzati determinati dati come il blocco estratto. Se la transazione è stata completata con successo, l’esploratore scriverà “successo” o “riuscito”.</p>
<p>Se la transazione non è riuscita, vedrai un messaggio che indica il tipo di errore come “istruzione errata”, “gas esaurito” o “revertita”. In alternativa, il risultato potrebbe mostrare un altro stato come “In attesa” o “Transazione non trovata”.</p>
<h2 id="h2-Comprensione20del20tempo20di20elaborazione20di20Ethereum774694"><a name="Comprensione del tempo di elaborazione di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione del tempo di elaborazione di Ethereum</h2><p>In una situazione normale, una transazione sulla rete Ethereum impiega circa 15 minuti e cinque secondi per completarsi. Tuttavia, ciò dipende da diversi fattori come l’importo della commissione di transazione pagata e quanto è occupata la rete ETH.</p>
<p>Il numero di transazioni in corso di elaborazione è importante perché tutte vanno nel mempool di Ethereum, dove i validatori le scelgono per la convalida. Principalmente, il mempool funge da sala d’attesa dove le transazioni in sospeso rimangono fino a quando vengono convalidate o respinte. La transazione diventa completa se i suoi dati vengono inseriti in un blocco che viene quindi aggiunto alla blockchain.</p>
<h2 id="h2-Cosa20succede20se20una20transazione20Ethereum20fallisce766474"><a name="Cosa succede se una transazione Ethereum fallisce?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succede se una transazione Ethereum fallisce?</h2><p>Una delle ragioni per cui le transazioni sulla rete ETH falliscono è il gas insufficiente. Tuttavia, se un utente nota che il gas è inferiore a quanto richiesto, può rieseguire la transazione. In questo caso è possibile aumentare la commissione di accompagnamento. È importante assicurarsi che la transazione abbia lo stesso nonce. Quando si riesegue una transazione, i validatori approveranno quella più recente.</p>
<h2 id="h2-Il20modo20migliore20per20effettuare20transazioni535178"><a name="Il modo migliore per effettuare transazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il modo migliore per effettuare transazioni</h2><p>Se non hai intenzione di impacchettare i dati della tua transazione e semplicemente inviare token a un altro account, la transazione tramite Gate.io diventa l’opzione più senza stress. Devi semplicemente selezionare il token che desideri inviare, scegliere la catena su cui deve essere inviato e fare clic su Invia. Registrati con <a href="https://www.gate.io/" target="_blank">Gate.io</a> per iniziare a effettuare transazioni.</p>
<h2 id="h2-Conclusione309024"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Molti amanti delle criptovalute hanno un’elevata probabilità di utilizzare la rete Ethereum per effettuare alcune transazioni. Il motivo è che la blockchain ha molte applicazioni decentralizzate. Pertanto, dovrebbero sapere come controllare lo stato delle loro transazioni utilizzando diversi esploratori di blockchain Ethereum.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Mashell C. </strong>, Ricercatore di 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 il riposting dell'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>