TXQuIEdveCdzIHZlcmh1aXppbmc6IE1pbGphcmRlbiBpbiBCaXRjb2luIG92ZXJnZXpldCBuYWFyIGVlbiBuaWV1d2UgcG9ydGVtb25uZWU=

2024-07-17, 08:17

<p><img src="https://gimg2.gateimg.com/image/article/17212037471690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR628212"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 5 juli heeft Mt Gox meer dan 47.000 overgemaakt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> van zijn koude opslag naar een andere digitale portemonnee, een teken dat de herverdeling van zijn BTC mogelijk is begonnen.</p>
<p>De herverdeling van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> door Mt Gox kan leiden tot een massa-verkoop die kan resulteren in een daling van de prijs.</p>
<p>Er is een lage kans dat Mt Gox opnieuw zal verschijnen als een gereguleerde cryptocurrency exchange.</p>
<h2 id="h2-Introductie814830"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De effecten van crypto misdaden kunnen lange tijd bij de sector blijven. Bijvoorbeeld, na hackincidenten kan het jaren duren voordat sommige DeFi-bedrijven hun activiteiten hervatten. Hoewel crypto-projecten zoals FTX en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Luna waren geen slachtoffers van crypto-hacking, ze zijn er niet in geslaagd zich te herstellen na hun implosies.</p>
<p>De zaak van Mt Gox illustreert de verwoestende effecten van hacking op cryptobedrijven. Hoewel het er niet in geslaagd is om zijn cryptobeursactiviteiten te hervatten, heeft het nog steeds een verplichting tegenover zijn investeerders. In deze tekst wordt de strategie van Mt Gox voor het wegwerken van schulden na zijn ondergang besproken.</p>
<p>Lees ook: <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">Paniek rond verkoop van Duitse en Mt. Gox adressen neemt af na herstel van de markt vanuit dieptepunten.</a></p>
<h2 id="h2-Mt20Gox20verstuurt20meer20dan204700020BTC20in20een20poging20om20zijn20schuldeisers20te20betalen850052"><a name="Mt Gox verstuurt meer dan 47.000 BTC in een poging om zijn schuldeisers te betalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mt Gox verstuurt meer dan 47.000 BTC in een poging om zijn schuldeisers te betalen</h2><p>In een beweging die mogelijk verband houdt met zijn plan om zijn schuldeisers terug te betalen, heeft Mt Gox 47.228 BTC ter waarde van ongeveer $ 2,71 miljard overgemaakt van zijn koude opslag naar een nieuwe portemonnee. Als deze stap verband houdt met zijn plan om zijn schuldeisers terug te betalen, markeert dit een kritiek moment voor de cryptowereld. Dit komt omdat de overdracht van grote hoeveelheden bitcoin aan de schuldeisers binnen een korte tot lange termijn kan leiden tot een hoge verkoopdruk. Zoals de volgende schermafbeelding aangeeft, heeft Arkham Intel de overdracht van bitcoin door Mt Gox aangekondigd. <img src="https://gimg2.gateimg.com/image/article/17212038241.jpg" alt=""><br>Bron: x.com</p>
<p>Zoals de afbeelding aangeeft, stuurde Mt Gox een bedrag aan bitcoin naar een digitale portemonnee waarvan de eigenaar nog steeds onbekend is voor het publiek. Ondanks een dergelijke overdracht van een groot bedrag aan bitcoin houdt Mt Gox nog steeds meer dan 138.000 BTC vast. Desalniettemin heeft Arkam Intel volgehouden dat deze bitcoin-overdracht betrekking heeft op de betaling voor Mt Gox-schuldeisers.</p>
<p>Na het overzetten van de meer dan 47.000 BTC van zijn cold wallet naar een ander crypto walletadres heeft Mt Gox opnieuw 1.545 BTC verplaatst naar een hot wallet die toebehoort aan een van de crypto-exchanges genaamd Bitbank, die betrokken is bij de terugbetaling van de schuldeisers. De bovenstaande transacties lijken te bevestigen dat de recente grote bitcointransactie verband houdt met het proces van terugbetaling aan de schuldeisers.</p>
<p>Volgens een recente publicatie van CoinDesk gelooft Willy Chuang, COO van crypto exchange WOO X, sterk dat de grote bitcointransactie het begin betekende van de terugbetaling aan Mt Gox-schuldeisers. <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 zei</a> Mt. Gox heeft 47.228 BTC verplaatst, wat het begin van hun terugbetalingsproces aangeeft. Dit heeft enige marktvrees veroorzaakt vanwege de mogelijke grote verkoop.</p>
<p>Op basis van de bovenstaande blockchain transactieanalyse kunnen de cryptotransfers van Mt Gox in overeenstemming zijn met de wettelijke bepalingen die het liquidatieproces in Japan regelen. Volgens Arkham Intelligence heeft Mt Gox in het verleden verschillende andere kleinere transacties uitgevoerd, zoals blijkt uit de volgende afbeelding.</p>
<p>Lees ook: <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">Diepgaande analyse van de</a><img src="https://gimg2.gateimg.com/image/article/17212040492.jpg" alt=""><br>Mt Gox Bitcoin Transfers - Arkham Intelligence</p>
<p>Sommige analisten geloven dat Mt Gox de reeks kleine betalingen heeft gedaan als testtransacties ter voorbereiding op het volledige schuldeiser-terugbetalingsproces. Op basis van een 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">publicatie door TheBlock</a> In juni kondigde Mt Gox aan dat het meer dan $9 miljard zou uitkeren in bitcoin (BTC). <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> Vanaf juli zal Mt. Gox $9 miljard aan zijn crediteuren uitbetalen in Bitcoin (BCH) en fiatgeld. Dit bedrag bestaat uit 142.000 BTC (ongeveer $8 miljard), 143.000 BCH (45,9 miljoen dollar) en 69 miljard Japanse yen (428,7 miljoen dollar).</p>
<h2 id="h2-Cryptomarktanalyse20De20opkomst20en20ondergang20van20Mt20Gox492114"><a name="Crypto-marktanalyse: De opkomst en ondergang van Mt Gox" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto-marktanalyse: De opkomst en ondergang van Mt Gox</h2><p>Mt Gox, opgericht in 2010, werd de grootste bitcoinbeurs totdat het in 2014 instortte. Tijdens zijn operationele periode handelde het tussen 70% en 80% van alle bitcointransacties af. Niettemin werd de beurs in februari 2014 gehackt, wat leidde tot een verlies van meer dan 850.000 bitcoin, gewaardeerd op ongeveer $600 per stuk. Als gevolg van dat hackincident verklaarde de beurs in datzelfde jaar faillissement.</p>
<p>Later bedacht het het civiele rehabilitatieplan om zijn voormalige klanten te compenseren. In 2018 diende het zijn rehabilitatieplan in bij de Tokyo District Court en de rechtbank keurde het plan goed in maart 2019. Hoewel het kort na de goedkeuring van het plan begon met de herverdeling van de activa, verliep het proces moeizaam en traag.</p>
<p>Belangrijk om te weten: <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">Hoe Bitcoin te kopen op Gate.io</a></p>
<h2 id="h2-Mt20Goxs20Versneld20Activa20Herverdelingsproces20en20Marktreactie990302"><a name="Mt Gox’s Versneld Activa Herverdelingsproces en Marktreactie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mt Gox’s Versneld Activa Herverdelingsproces en Marktreactie</h2><p>De cryptomarkt heeft niet lang gewacht om te reageren nadat Mt Gox meer dan 47.000 BTC vanuit hun koude opslag naar een crypto wallet-adres heeft overgezet waarvan de eigenaar nog niet geïdentificeerd is. Binnen enkele uren steeg de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> zakte onder de $57.000. En gedurende de volgende 24 uur daalde de waarde verder met meer dan 3,45% om te handelen op ongeveer $56.851.</p>
<p>De plotselinge reactie van de bitcoinmarkt leidde investeerders om een sterke prijsdaling te voorspellen na de herverdeling van de meer dan 142.000 bitcoin aan de crediteuren. Hierover citeerde TheBlock Rachael Lucas, Crypto-analist bij BTC Markets, als volgt: “Deze aanzienlijke uitbetaling, ter waarde van 9 miljard dollar, zal naar verwachting aanzienlijke verkoopdruk toevoegen terwijl de markt de extra voorraad opneemt.”</p>
<p>John Glover, chief investment officer van Ledn, een crypto-uitleenbedrijf, is nog een analist die gelooft dat de herverdeling van bitcoin door Mt Gox veel verkoopdruk zal creëren. In een interview met 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 zei</a>, ‘Velen zullen duidelijk hun geld opnemen en genieten van het feit dat het hebben van hun activa vastzat in het faillissement van Mt. Gox de beste investering was die ze ooit hebben gedaan.’ Hij voegde eraan toe: ‘Sommigen zullen duidelijk kiezen om het geld te nemen en te vertrekken.’</p>
<p>Desalniettemin zijn de crypto-analisten van JP Morgan van mening dat de marktimpact van de herverdeling van bitcoin in de cryptocurrency-markt van korte duur zal zijn. Ze vertelden CNBC: “Als de meeste liquidaties door Mt. Gox-schuldeisers plaatsvinden in juli, creëert dit een traject waarbij de cryptoprijzen in juli verder onder druk komen te staan, maar vanaf augustus weer beginnen te herstellen.”</p>
<p>Daarentegen hebben sommige leden van de cryptogemeenschap de impact van de herverdeling van Mt Gox-bitcoin op de prijs gebagatelliseerd. Bijvoorbeeld, Alex Thorn, hoofdonderzoeker bij Galaxy Digital, gelooft dat sommige van de ontvangers van bitcoin ‘diamond handed’ zijn. Als zodanig zouden ze kunnen besluiten om hun BTC vast te houden, zodat ze kunnen profiteren van een verdere prijsstijging als gevolg van de speculatieve neigingen op de bitcoinmarkt, tenzij er onverwachte veranderingen zijn in de cryptoregulering of macro-economische omstandigheden. Zoals we weten, zijn sommige toonaangevende economieën zoals de Verenigde Staten en regionale instanties zoals de EU bezig met het invoeren van nieuwe cryptoregels. Een van de recent geïntroduceerde cryptowetten is de Markets in Crypto-Assets Regulation (MiCA) van de EU.</p>
<p>Ondertussen zou de herverdeling van bitcoin door Mt Gox positieve juridische implicaties voor cryptocurrencies moeten hebben. Dit komt doordat de failliete cryptobeurs leek te voldoen aan de faillissementsregels en crypto wetgeving van Japan. Afgaande op wat we zien, viel de overdracht van meer dan 47.000 door Mt Gox binnen de bepalingen van de relevante wetten.</p>
<h2 id="h2-Heeft20Mt20Gox20een20rooskleurige20toekomst20of20is20het20somber84729"><a name="Heeft Mt Gox een rooskleurige toekomst of is het somber?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Mt Gox een rooskleurige toekomst of is het somber?</h2><p>Een van de belangrijkste vragen in de gedachten van veel mensen is of Mt Gox zich zal herpositioneren en doorgaan met zijn cryptobedrijfsactiviteiten. Aangezien Mt Gox lijkt te hebben voldaan aan de digitale activaregels van Japan, kan het ervoor kiezen om zijn cryptobedrijf nieuw leven in te blazen. Hoewel dit gerucht al enige tijd binnen de cryptogemeenschap circuleert, is er geen officiële bevestiging van Mt Gox. Als gevolg hiervan zijn er geen tijdschema’s voor heropening. Er bestaat echter een mogelijkheid dat het opnieuw opkomt als een gereguleerde en legitieme cryptocurrency-uitwisseling.</p>
<h2 id="h2-Conclusie598666"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In juni kondigde Mt Gox aan dat het in juli zou beginnen met de herverdeling van bitcoin en andere activa aan zijn schuldeisers. Later, in een ontwikkeling die sommige analisten beschouwen als het begin van het terugbetalingsproces, verplaatste de beurs meer dan 47.000 bitcoin van zijn koude opslag naar een cryptoportefeuille-adres waarvan de eigenaar nog niet bekend is. Ondertussen hebben sommige marktanalisten gesuggereerd dat de herverdeling van meer dan 142.000 bitcoin van Mt Gox kan leiden tot een massale verkoop, waardoor de waarde ervan wordt verlaagd.</p>
<div class="blog-details-info"><br><div>Auteur: <em> Mashell C. </em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>