RlRYIHRvb250IGVub3JtZSB0ZWtvcnRlbiBpbiBkZSBhY3RpdmEgdmFuIGhldCBiZWRyaWpm

2023-03-30, 04:34
<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR168884"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De financiële gegevens van FTX en FTX.US tonen aan dat de twee entiteiten enorme financiële tekorten hebben.</p>
<p>De FTX-schuldenaars zijn degenen die de enorme financiële tekorten van FTX aan het licht hebben gebracht.</p>
<p>FTX Japan en GameStop (GME) hebben beloofd hun klanten terug te betalen.</p>
<h2 id="h2-Introductie69605"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De FTX-crash is een van de meest opvallende ontwikkelingen <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">die een negatieve invloed had op de cryptosector in 2022</a>. Deze misser heeft nog steeds invloed op veel gedecentraliseerde projecten en beïnvloedt besluitvorming op verschillende niveaus. Zo zijn de meeste nationale overheden bezig met het introduceren en handhaven van relevante cryptoregulering om vergelijkbare scenario’s te voorkomen.</p>
<h2 id="h2-Tekorten20in20portefeuilles20en20fiataccounts617072"><a name="Tekorten in portefeuilles en fiat-accounts" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tekorten in portefeuilles en fiat-accounts</h2><p>Het lopende onderzoek naar de oorzaken van de instorting van de FTX-cryptobeurs heeft tekortkomingen aangetoond in zijn digitale portefeuilles en fiatrekeningen. Er zijn ook tekorten op de rekeningen van FTX.US, een zusteronderneming van de FTX-cryptobeurs.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150505461680150219_.pic.jpg" alt=""><br>FTX crypto exchange- CNBC</p>
<p>De FTX-schuldenaars onthulden enorme hiaten in de financiële verslagen van de twee bedrijven tijdens hun presentatie voor de FTX-faillissementszaak. Uit het financiële onderzoek bleek dat FTX $2,2 miljard aan activa heeft, waarvan de meeste illiquide zijn. Volgens de presentatie bedraagt alleen $694 miljoen aan activa, inclusief <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, Ether en andere cryptocurrencies zijn liquide.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2268/britain-sets-to-regulate-the-crypto-after-ftx-collapse" target="_blank">Groot-Brittannië stelt zich in op regulering van Crypto na val FTX</a></p>
<p>FTX’s klantenvorderingen bedragen $385 miljoen terwijl er $9.3 miljard netto leningen worden verstrekt door Alameda Research, het zusterbedrijf. De onderzoekers hebben echter duidelijk gemaakt dat de bevindingen niet concluderend zijn vanwege de aard van de financiële gegevens die voorhanden zijn. Er bestaat een mogelijkheid dat het team andere onregelmatigheden zal ontdekken.</p>
<p>In een reactie op de staat van de beschikbare financiële gegevens heeft John J. Ray III, de Chief utive Officer en Chief Restructuring Officer van de FTX-debiteuren <a href="https://www.prnewswire.com/news-releases/ftx-debtors-publish-second-presentation-for-stakeholders-301761345.html" rel="nofollow noopener noreferrer" target="_blank">zei</a>“Het heeft enorm veel moeite gekost om tot hier te komen. De activa van de beurzen waren sterk vermengd en hun boeken en records zijn onvolledig en in veel glen volledig afwezig. Om deze redenen is het belangrijk om te benadrukken dat deze informatie nog steeds voorlopig is en kan veranderen.”</p>
<p>In een persbericht voegde het onderzoeksteam toe: “De presentatie bevat ook informatie over hoe het voorlopige management van FTX vermengde activa gebruikte, door FTX.com en FTX.US sweep wallets om digitale activa op te slaan, te lenen en uit te lenen voor de eigen rekening van de FTX Debtors en aanverwante partijen, inclusief werknemers, leveranciers, verkopers en zakenpartners, evenals exchange-klanten.”</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">Belangrijke lessen uit de ineenstorting van FTX en de implosie van FTT</a></p>
<p>De onderzoekers merkten ook op dat er verschillende ongeautoriseerde transacties waren gedaan. Voor FTX USA bedraagt de totale waarde van de via ongeautoriseerde transacties uit zijn portefeuilles opgenomen gelden $293 miljoen. Aan de andere kant bedraagt het bedrag van de ongeautoriseerde transacties voor FTX.US $139 miljoen. De volgende tabel toont de huidige financiële status van FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150770471680150230_.pic.jpg" alt=""></p>
<p>Zoals u kunt zien in de tabel, zijn er twee categorieën digitale activa. Alle activa in categorie A hebben tekorten, terwijl die in categorie B overschotten hebben. Categorie A omvat belangrijke cryptocurrencies, zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, Ether, Sol, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, Matic, en <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> onder andere.</p>
<p>Aan de andere kant bestaat categorie A uit cryptocurrencies met lage handelsvolumes zoals MAPS, Serum en Fida. Niettemin compenseren de overschotten voor activa van categorie B de tekorten van die van categorie A niet.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">FTX-evenement en de gevolgen ervan?</a></p>
<p>De financiële gegevens van FTX.US tonen ook verschillende afwijkingen van verschillende grootte. Op basis van de spotprijzen op het moment van het verzoek heeft FTX.US digitale activa ter waarde van $191 miljoen, $28 miljoen aan vorderingen van klanten en $155 miljoen aan andere vorderingen. Aan de andere kant heeft het in totaal $107 miljoen aan verschuldigdheid aan Alameda Research.</p>
<p>De schuldenaars van FTX hebben echter duidelijk gemaakt dat het proces om de bijgewerkte financiële gegevens te krijgen moeilijk is geweest, wat mogelijk heeft geleid tot kleine verschillen. Ze meldden: ‘De informatie in de presentatie is voorlopig en kan aan verandering onderhevig zijn. De analyse wordt verder gecompliceerd door de onvolledige aard van de boeken en verslagen en financiële informatie die wordt bijgehouden door het pre-petitiemanagement.’</p>
<h2 id="h2-Wanneer20werd20het20tekort20van20FTX20en20FTXUS20onthuld129362"><a name="Wanneer werd het tekort van FTX en FTX.US onthuld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wanneer werd het tekort van FTX en FTX.US onthuld?</h2><p>Het enorme tekort voor FTX en FTX.US werd onthuld door de FTX Debtors die het g onderzochten en rapporten indienden voor de FTX-hoofdstuk 11 faillissementszaak. In feite vereiste het blootleggen van het tekort veel moeite en grondig onderzoek. De ontbrekende fondsen werden onthuld op 2 maart 2023 toen de FTX Debtors hun presentaties maakten als onderdeel van de hoofdstuk 11 faillissementsprocedure.</p>
<p>Desalniettemin is het belangrijk op te merken dat de fondsen van de klant gedurende een lange periode verdwenen zijn. Waarschijnlijk verdween een deel van de fondsen voordat het FTX-team faillissement aanvroeg. Het veelbesproken FTX-nieuws toont aan dat een deel van de fondsen vermist raakte vanaf het moment dat FTX faillissement aanvroeg. Daarom hebben sommige analisten erop gewezen dat sommige van de verloren activa door hacking na het faillissementsfiling deel uitmaakten van een interne klus.</p>
<h2 id="h2-Opties20voor20terugbetaling496857"><a name="Opties voor terugbetaling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opties voor terugbetaling</h2><p>De meeste FTX-klanten willen weten of er restituties zullen zijn. In november 2022 beloofde FTX Japan om zijn klanten in februari 2023 terug te betalen. De restitutie zou verwerkt moeten worden via Liquid Japan, een crypto-uitwisseling. Als gevolg hiervan verzocht FTX Japan zijn klanten om accounts te openen bij Liquid Japan. De exacte datum van de restitutie hangt echter af van de uitkomst van het lopende controleproces.</p>
<p>Het is ook mogelijk dat sommige FTX-partners hun klanten zouden terugbetalen die getroffen zijn door het instorten van de cryptobeurs. Zo kondigde bijvoorbeeld op 11 november vorig jaar de videogameverkoper GameStop (GME) aan dat het van plan was zijn klanten terug te betalen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150828481680150249_.pic.jpg" alt=""><br>GameStop zal zijn klanten terugbetalen - Twitter</p>
<p>Zoals u kunt verwachten, kunnen terugbetalingen door derden kleine bedragen aan geld inhouden.</p>
<h2 id="h2-Conclusie473827"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>FTX en FTX.US hebben grote tekorten, zoals blijkt uit de financiële verslagen, samengesteld door de FTX-debiteuren en gepresenteerd voor het doel van het FTX-hoofdstuk 11 faillissementszaak. Een deel van dit bedrag waren ongeautoriseerde opnames die plaatsvonden nadat FTX faillissement had aangevraagd. Opmerkelijk is dat FTX Japan en GameStop (GME) beloofden om zijn klanten terug te betalen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards