TWluYXRvcmUgcmVzdGl0dWlzY2Ugb2x0cmUgJDUwMCBLIGRpIHNvdnJhcHBhZ2FtZW50byBkZWxsZSBjb21taXNzaW9uaSBkaSB0cmFuc2F6aW9uZSBpbiBCVEMgYSBQYXhvcw==

2023-09-28, 03:15

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR196315"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il minatore di criptovalute, F2Pool, ha restituito un valore di $500 K di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> che Paxos ha pagato per errore.</p>
<p>F2Pool ha agito responsabilmente restituendo l’importo BTC pagato in eccesso.</p>
<p>I portafogli digitali pagano commissioni di transazione quando inviano, ricevono o scambiano criptovalute.</p>
<h2 id="h2-Introduzione51319"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La cosa positiva delle transazioni basate su blockchain è che sono immutabili, affidabili e trasparenti. Inoltre, chiunque o qualsiasi parte è libero di verificarle in quanto sono a prova di manomissione. Tuttavia, a causa di certi bug o errori umani, i protocolli decentralizzati potrebbero eseguire transazioni errate. In questo articolo, esploriamo come un minatore onesto ha restituito i <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> che erano <a href="https://www.gate.io/blog_detail/1355/how-to-transfer-crypto-anonymously" target="_blank">trasferito al suo portafoglio</a> per errore.</p>
<h2 id="h2-Un20Bitcoin20Miner20ha20restituito20oltre20500K20BTC944871"><a name="Un Bitcoin Miner ha restituito oltre 500K BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un Bitcoin Miner ha restituito oltre 500K BTC</h2><p>Un minatore di bitcoin, F2Pool, ha restituito 19,8 BTC del valore di circa 500.000 dollari che Paxos ha erroneamente trasferito sul suo conto. In sostanza, Paxos voleva trasferire solo 0,074 BTC del valore di meno di 2.000 dollari. Tuttavia, un bug nel sistema ha causato una commissione di transazione inflazionata, probabilmente la commissione più alta registrata sulla rete bitcoin negli ultimi anni.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/2285/new-york-regulators-probes-stablecoin-issuer-paxos" target="_blank">I regolatori di New York indagano sullo stabilimento dell’emittente di stablecoin, Paxos</a></p>
<p>Ci sono alcune spiegazioni per quell’anomalia di sovrapagamento. Ad esempio, Jameson Lopp, co-fondatore di CasaHODL, ritiene che l’importo della transazione sia stato gonfiato a causa di un bug sullo scambio o sul sistema del processore di pagamento. Poiché l’indirizzo aveva eseguito oltre 600.000 transazioni, potrebbe aver commesso un errore nel processo.</p>
<p>In base all’output della transazione, alcune persone hanno suggerito che l’errore potesse essere collegato a PayPal. Tuttavia, Paxos ha smentito che PayPal fosse responsabile dell’errore.</p>
<p>Alcuni analisti suggeriscono anche che il sovrapprezzo potrebbe essere stato il risultato di un errore di copia e incolla durante l’elaborazione di diverse transazioni verso diversi indirizzi del portafoglio. In tal caso, l’indirizzo F2Pool potrebbe essere stato copiato e incollato più volte.</p>
<p>Qualsiasi spiegazione sia stata data, Paxos ha accettato la piena responsabilità per l’errore e ha detto che ha colpito solo le sue operazioni aziendali. Non ci sono stati altri account clienti, a parte quello di F2Pool, il minatore di criptovalute, che sono stati colpiti.</p>
<p>Dopo aver realizzato il suo errore, Paxos ha contattato F2Pool per rivendicare l’importo sovrastimato della commissione di transazione. Tuttavia, Chun Wang, co-fondatore di F2Pool, ha dichiarato che la richiesta di annullamento è stata fatta al di fuori del tempo stabilito a causa delle differenze di fuso orario. La regola vigente prevede che le commissioni pagate in eccesso debbano essere richieste entro tre giorni. La mancata richiesta comporterà la ridistribuzione delle commissioni tra i minatori.</p>
<p>Wang ha dichiarato: “Ero irritato e mi sono pentito di aver accettato di rimborsare quei 20 BTC. Soprattutto quando ho visto la persona che lo richiedeva continuare a dire EST invece di EDT/UTC. L’ultima volta un <a href="/price/zcash-zec" rel="nofollow noopener noreferrer" target="_blank">Zcash</a> quel ragazzo ha fatto così, ho bloccato l’intera sua azienda.</p>
<p>Tuttavia, c’è stato molto dibattito nella comunità crittografica su X (ex Twitter) su se restituire o meno l’importo pagato in eccesso a Paxos. In un sondaggio successivo, il 37% dei partecipanti ha detto che l’importo avrebbe dovuto essere ridistribuito ai minatori.</p>
<p>27% pensava che F2Pool dovesse restituire la sovrapagamento a Paxos. Il resto era diviso su restituire l’importo totale a Paxos o dividerlo in una50⁄50modo tra Paxos e i minatori. Tuttavia, alla fine F2Pool ha restituito l’intero importo a Paxos.</p>
<p>F2Pool ha confermato di aver restituito i fondi a Paxos. <a href="https://twitter.com/f2pool_official/status/1702600488963940669" rel="nofollow noopener noreferrer" target="_blank">È scritto su X</a> (precedentemente Twitter), “Dopo aver effettuato la verifica dell’identità, abbiamo confermato la proprietà di questi BTC e rimborsato interamente la commissione al mittente.”</p>
<p>In risposta <a href="https://twitter.com/lopp/status/1702642904089477372" rel="nofollow noopener noreferrer" target="_blank">Jameson Lopp ha commentato su F2Pool</a> per restituire i fondi in modo amichevole. Ha detto: “Bitcoin è una rete avversaria, ma d’altra parte è anche una rete cooperativa.”</p>
<p>Ha aggiunto: “Anche i minatori sono umani e si rendono conto che le persone commettono errori. Sebbene trattenere commissioni di transazione eccessive porti a un bel profitto a breve termine, restituire quei fondi è una decisione umana.”</p>
<p>L’azione di entrambe le parti, Paxos e F2Pool, ha dimostrato che esiste responsabilità e affidabilità tra molti attori nel settore della blockchain. Inoltre, il fatto che F2Pool abbia verificato l’errore utilizzando l’esploratore di bitcoin dimostra che esiste trasparenza nel settore delle criptovalute.</p>
<h2 id="h2-Transazioni20di20criptovaluta33001"><a name="Transazioni di criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Transazioni di criptovaluta</h2><p>Abbiamo notato che i bug su una rete possono portare a errori durante l’invio e la ricezione di asset digitali. In questo caso, l’errore ha comportato l’invio delle commissioni di transazione a un pool di mining.</p>
<p>In termini semplici, le commissioni di transazione sono addebiti applicati a un portafoglio che invia asset digitali o esegue qualsiasi altra transazione come il trading di criptovalute su un exchange. Una parte dell’importo addebitato viene versata ai minatori che convalidano le transazioni su una specifica blockchain.</p>
<p>Le piattaforme di trading e gli exchange di criptovalute applicano commissioni sulle transazioni quando le persone comprano, vendono o trasferiscono asset digitali come criptovalute e token non fungibili (NFT). Ad esempio, ogni volta che un individuo invia BTC attraverso la rete blockchain, viene addebitata una commissione. <a href="https://www.gate.io/hot_news/detail/114/which-exchange-offers-the-lowest-transaction-fee-to-buy-bitcoin" target="_blank">commissione di transazione bitcoin</a>.</p>
<p>Le commissioni servono a diversi scopi, come limitare le transazioni dannose sulla rete. Se non ci sono commissioni di transazione, il sistema potrebbe ricevere molti messaggi indesiderati. Inoltre, queste commissioni sostengono anche gli scambi di criptovalute e… <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">altre piattaforme di trading DeFi</a> in quanto sono la principale fonte dei loro ricavi.</p>
<p>Nella maggior parte dei casi, le commissioni sono molto basse. Tuttavia, possono aumentare quando ci sono molte transazioni su una rete durante un periodo specifico. Le commissioni di transazione sulla rete bitcoin vengono pagate in BTC mentre quelle su <a href="https://www.gate.io/bitwiki/detail/102/ethereum" target="_blank">Blockchain Ethereum</a> vengono pagati in Ether (ETH).</p>
<p>Articolo correlato: <a href="https://www.gate.io/de/blog_detail/90/how-long-does-it-take-to-mine-1-bitcoin" target="_blank">Quanto tempo ci vuole per estrarre 1 bitcoin</a></p>
<h2 id="h2-Ricompense20di20mining570400"><a name="Ricompense di mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricompense di mining</h2><p>La ricompensa di mining, chiamata anche ricompensa di blocco, è la quantità di criptovaluta che una società di mining di criptovalute riceve dopo aver validato le transazioni. Attualmente, ad esempio, quando una società di mining di bitcoin aggiunge un blocco alla blockchain, riceve 6,25 BTC. Alcune società minerarie formano <a href="https://www.gate.io/bitwiki/detail/4/mining-pool" target="_blank">pool di mining</a> aumentare la loro potenza di calcolo e ricompensa.</p>
<p>Tuttavia, la quantità di bitcoin che le aziende che estraggono BTC ottengono per ogni blocco di successo diminuisce ogni volta che si verifica un evento di halving di bitcoin. Il prossimo evento di halving di bitcoin avrà luogo nell’aprile 2024, il che comporterà la riduzione delle ricompense dei minatori da 6,25 BTC a 3,125 per ogni blocco di successo.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/250/gate.io-observation-how-to-use-cloud-mining-to-mine-bitcoin-in-just-one-click" target="_blank">Come utilizzare il cloud mining per estrarre Bitcoin con un solo clic?</a></p>
<h2 id="h2-Conclusion276477"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>F2Pool ha restituito quasi 20 BTC quando Paxos ha effettuato un pagamento eccessivo di commissioni di transazione per errore. L’errore di transazione potrebbe essere avvenuto a causa di un problema nella rete di Paxos. Tuttavia, la collaborazione tra F2Pool e Paxos dimostra che le aziende e le persone nel settore delle criptovalute possono essere responsabili e responsabili.</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 riutilizzo dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>