TGEgbW9zc2EgZGkgTXQuIEdveDogbWlsaWFyZGkgZGkgQml0Y29pbiB0cmFzZmVyaXRpIGluIHVuIG51b3ZvIHBvcnRhZm9nbGlv

2024-07-17, 08:17

<p><img src="https://gimg2.gateimg.com/image/article/17212037471690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR112231"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 5 luglio Mt Gox ha trasferito oltre 47.000 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> dal suo storage a freddo a un altro portafoglio digitale, un segno che potrebbe essere iniziata la sua ridistribuzione di BTC.</p>
<p>La ridistribuzione di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> di Mt Gox potrebbe portare a una vendita di massa che potrebbe causarne la caduta del prezzo.</p>
<p>C’è una bassa possibilità che Mt Gox possa rilanciarsi con un nuovo nome e riemergere come una borsa di criptovalute regolamentata.</p>
<h2 id="h2-Introduzione125829"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli effetti dei crimini legati alle criptovalute potrebbero rimanere nel settore per un lungo periodo. Ad esempio, dopo gli incidenti di hacking, alcune società DeFi potrebbero impiegare anni per riprendere le proprie attività. Anche se progetti criptovalutari come FTX e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna non sono stati vittime di hacking criptato non sono riusciti a riprendersi dopo le loro implosioni.</p>
<p>Il caso di Mt Gox illustra gli effetti devastanti dell’hacking sulle attività criptate. Nonostante abbia fallito nel riprendere la sua attività di scambio di criptovalute, ha comunque un obbligo nei confronti dei suoi investitori. Questo articolo discute la strategia di liquidazione del debito di Mt Gox a seguito della sua scomparsa.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/gate-research-germany-and-mt-gox-addresses-sell-off-panic-subsides-market-rebounds-from-lows/3479" target="_blank">Gli indirizzi di Germania e Mt. Gox vendono, il panico della vendita si attenua mentre il mercato si riprende dai minimi</a></p>
<h2 id="h2-Mt20Gox20trasferisce20oltre204700020BTC20mentre20cerca20di20pagare20i20suoi20creditori615817"><a name="Mt Gox trasferisce oltre 47.000 BTC mentre cerca di pagare i suoi creditori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mt Gox trasferisce oltre 47.000 BTC mentre cerca di pagare i suoi creditori</h2><p>In una mossa che potrebbe essere collegata al suo piano di ripagare i creditori, Mt Gox ha trasferito 47.228 BTC del valore di circa 2,71 miliardi di dollari dal suo deposito a freddo a un nuovo portafoglio. Se questa mossa è legata al suo piano di ripagare i creditori, segna un momento critico per il mondo delle criptovalute. Questo perché il trasferimento di grandi quantità di bitcoin ai creditori potrebbe portare a una forte pressione di vendita nel breve e lungo termine. Come indica la seguente schermata, Arkham Intel ha annunciato il trasferimento di bitcoin di Mt Gox.<img src="https://gimg2.gateimg.com/image/article/17212038241.jpg" alt=""><br>Origine: x.com</p>
<p>Come indica l’immagine, Mt Gox ha inviato una somma di bitcoin a un portafoglio digitale il cui proprietario è ancora sconosciuto al pubblico. Nonostante tale trasferimento di una grande quantità di bitcoin, Mt Gox detiene ancora oltre 138.000 BTC. Tuttavia, Arkam Intel ha mantenuto che questo trasferimento di bitcoin è legato al pagamento dei creditori di Mt Gox.</p>
<p>Dopo aver trasferito i oltre 47.000 BTC dal suo portafoglio a freddo a un altro indirizzo del portafoglio criptato, Mt Gox ha nuovamente spostato 1.545 BTC in un portafoglio caldo appartenente a uno degli scambi di criptovalute chiamato Bitbank, coinvolto nel processo di rimborso dei creditori. Le transazioni sopra sembrano confermare che la recente grande transazione di bitcoin è correlata al processo di rimborso dei creditori.</p>
<p>Secondo una recente pubblicazione di CoinDesk, Willy Chuang, COO dello scambio di criptovalute WOO X, crede fortemente che la grande transazione di bitcoin abbia segnato l’inizio del rimborso dei creditori di Mt Gox. <a href="https://www.coindesk.com/business/2024/07/05/mt-gox-begins-repayments-in-bitcoin-and-bitcoin-cash/" rel="nofollow noopener noreferrer" target="_blank">Chuang ha detto</a>“Mt. Gox ha spostato 47.228 BTC, segnalando l’inizio del processo di rimborso, il che ha causato un certo timore di mercato a causa del grande potenziale di vendita.”</p>
<p>In base all’analisi delle transazioni blockchain sopra riportata, i trasferimenti di criptovalute di Mt Gox potrebbero essere conformi alle disposizioni legali che regolano il processo di liquidazione in Giappone. Secondo Arkham Intelligence, Mt Gox ha effettuato diverse altre transazioni di minori dimensioni in passato, come indica l’immagine successiva.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/367/in-depth-analysis-of-the-mt.-gox-incident-from-7-years-ago-could-the-compensation-package-be-the-catalyst-for-a-major-bitcoin-sell-off" target="_blank">Analisi approfondita del</a><img src="https://gimg2.gateimg.com/image/article/17212040492.jpg" alt=""><br>Trasferimenti Mt Gox Bitcoin - Arkham Intelligence</p>
<p>Alcuni analisti ritengono che Mt Gox abbia effettuato una serie di piccoli pagamenti come transazioni di prova in preparazione per il processo di rimborso completo dei creditori. Sulla base di una recente <a href="https://www.theblock.co/post/301448/mt-gox-to-distribute-9-billion-of-bitcoin-bitcoin-cash-repayments-from-beginning-of-july" rel="nofollow noopener noreferrer" target="_blank">pubblicazione di TheBlock</a>, a giugno Mt Gox ha annunciato che avrebbe distribuito oltre $9 miliardi denominati in bitcoin (BTC), <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> (BCH) e denaro fiat ai suoi creditori a partire da luglio. I 9 miliardi di dollari comprendono 142.000 BTC (circa 8 miliardi di dollari), 143.000 BCH (45,9 milioni di dollari) e 69 miliardi di yen giapponesi (428,7 milioni di dollari).</p>
<h2 id="h2-Analisi20del20mercato20delle20criptovalute20la20salita20e20la20caduta20di20Mt20Gox307095"><a name="Analisi del mercato delle criptovalute: la salita e la caduta di Mt Gox" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi del mercato delle criptovalute: la salita e la caduta di Mt Gox</h2><p>Mt Gox, fondata nel 2010, è diventata il più grande scambio di bitcoin fino al suo crollo nel 2014. Durante il suo periodo operativo, era solita gestire tra il 70% e l’80% di tutte le transazioni di bitcoin. Tuttavia, nel febbraio 2014 lo scambio è stato hackerato, portando alla perdita di oltre 850.000 Bitcoin, del valore di circa $600 ciascuno. A seguito di quell’incidente di hacking, lo scambio ha dichiarato bancarotta nello stesso anno.</p>
<p>In seguito ha elaborato il piano di riabilitazione civile al fine di compensare i suoi ex clienti. Ha presentato il piano di riabilitazione al Tribunale del Distretto di Tokyo nel 2018 e il tribunale ha approvato il piano nel marzo 2019. Anche se ha iniziato a ridistribuire gli asset poco dopo l’approvazione del piano, il processo è stato complicato e lento.</p>
<p>Importante sapere: <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">Come acquistare Bitcoin su Gate.io</a></p>
<h2 id="h2-Il20processo20accelerato20di20ridistribuzione20degli20asset20di20Mt20Gox20e20la20reazione20del20mercato853051"><a name="Il processo accelerato di ridistribuzione degli asset di Mt Gox e la reazione del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il processo accelerato di ridistribuzione degli asset di Mt Gox e la reazione del mercato</h2><p>Il mercato delle criptovalute non ha impiegato molto tempo a rispondere dopo che Mt Gox ha trasferito oltre 47.000 BTC dalla sua conservazione a freddo a un indirizzo del portafoglio criptato il cui proprietario non è ancora stato identificato. Nel giro di poche ore il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo del Bitcoin</a> è precipitato al di sotto dei 57.000 dollari. E nelle successive 24 ore il suo valore è sceso ulteriormente di oltre il 3,45% per essere negoziato a circa 56.851 dollari.</p>
<p>La reazione improvvisa del mercato del bitcoin ha portato gli investitori a prevedere una forte caduta dei prezzi dopo la ridistribuzione dei oltre 142.000 bitcoin ai creditori. A tal proposito, TheBlock ha citato Rachael Lucas, analista criptografico di BTC Markets, dicendo: “Questo significativo pagamento, ammontante a 9 miliardi di dollari USA, è previsto che aggiunga una pressione di vendita sostanziale mentre il mercato assorbe l’offerta aggiuntiva.”</p>
<p>John Glover, direttore degli investimenti di Ledn, una società di prestiti crittografici, è un altro analista che ritiene che la ridistribuzione di bitcoin di Mt Gox creerà molta pressione sulla vendita. In un’intervista con CNBC <a href="https://www.cnbc.com/2024/07/05/mt-gox-begins-repaying-bitcoin-to-creditors-a-decade-on-from-collapse.html" rel="nofollow noopener noreferrer" target="_blank">Glover ha detto</a>, “Molti incasseranno chiaramente e si godranno il fatto che avere i loro beni bloccati nel fallimento di Mt. Gox è stato il miglior investimento che abbiano mai fatto”. Ha aggiunto: “Alcuni sceglieranno chiaramente di prendere i soldi e scappare.”</p>
<p>Tuttavia, gli analisti crittografici di JP Morgan ritengono che l’impatto del mercato delle criptovalute della ridistribuzione del bitcoin sarà di breve durata. Hanno detto a CNBC: “Assumendo che la maggior parte delle liquidazioni da parte dei creditori di Mt. Gox avvenga a luglio, [questo] crea una traiettoria in cui i prezzi delle criptovalute sono sottoposti a ulteriore pressione a luglio, ma iniziano a riprendersi da agosto in poi.”</p>
<p>Al contrario, alcuni membri della comunità cripto hanno minimizzato l’impatto della ridistribuzione del bitcoin di Mt Gox sul suo prezzo. Ad esempio, Alex Thorn, responsabile della ricerca presso Galaxy Digital, ritiene che alcuni dei destinatari di bitcoin siano “mano di diamante”. Pertanto, potrebbero decidere di tenere i loro BTC al fine di trarre vantaggio dalla sua ulteriore crescita di prezzo come risultato delle tendenze di speculazione sul mercato del bitcoin, a meno che non ci siano cambiamenti imprevisti nelle normative cripto o nelle condizioni macroeconomiche. Come sappiamo, alcune delle principali economie come gli Stati Uniti e gli organismi regionali come l’UE stanno attualmente procedendo all’emanazione di nuove normative cripto. Una delle recenti leggi cripto introdotte è il Regolamento sui mercati degli asset crittografici (MiCA) dell’UE.</p>
<p>Nel frattempo, la ridistribuzione del bitcoin di Mt Gox dovrebbe avere implicazioni legali positive per le criptovalute. Questo perché sembra che la defunta borsa di criptovalute abbia rispettato le normative fallimentari e la legge sulle criptovalute del Giappone. A quanto pare, il trasferimento di oltre 47.000 bitcoin da Mt Gox è avvenuto nel rispetto delle disposizioni di legge pertinenti.</p>
<h2 id="h2-Il20futuro20di20Mt20Gox2020luminoso20o20cupo688617"><a name="Il futuro di Mt Gox è luminoso o cupo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il futuro di Mt Gox è luminoso o cupo?</h2><p>Una delle domande principali nella mente di molte persone è se Mt Gox si rebrandizzerà e continuerà con le sue operazioni criptate. Poiché Mt Gox sembra essersi conformata alle normative giapponesi sugli asset digitali, potrebbe scegliere di rilanciare il suo business criptato. Anche se tale voce è stata presente nella comunità criptata per un po ‘di tempo, non c’è conferma ufficiale da Mt Gox. Di conseguenza, non ci sono scadenze per la sua riapertura. Tuttavia, c’è la possibilità che possa riemergere come un exchange di criptovalute regolamentato e legittimo.</p>
<h2 id="h2-Conclusion168794"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>A giugno Mt Gox ha annunciato che avrebbe iniziato la ridistribuzione di bitcoin e altri asset ai suoi creditori a luglio. In seguito, in uno sviluppo che alcuni analisti ritengono segnasse l’inizio del processo di rimborso, lo scambio ha spostato oltre 47.000 bitcoin dal suo deposito a freddo a un indirizzo del portafoglio crittografico il cui proprietario non è ancora noto. Nel frattempo, alcuni analisti di mercato hanno suggerito che la ridistribuzione di oltre 142.000 bitcoin di Mt Gox potrebbe portare a una massiccia liquidazione che potrebbe far scendere il suo valore.</p>
<div class="blog-details-info"><br><div>Autore:<em> Mashell C.</em>, 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>