TGFhdHN0ZSBGVFgtbmlldXdzOiAkMTAgbWlsamFyZCB0ZXJ1Z2JldGFsaW5nIGJlZ2ludCwgOTglIHZhbiBkZSBnZWJydWlrZXJzIHdvcmR0IGRpdCBqYWFyIGdlY29tcGVuc2VlcmQ=

2025-06-11, 03:42

<p><img src="https://gimg2.gateimg.com/image/ftx202506111141259477983550.png" alt="">
</p><p>De faillissementsrechtbank van Delaware heeft op 7 oktober 2024 officieel het faillissementsplan van FTX goedgekeurd, waarmee het de procedure voor schuldeiserscompensatie kan starten met maximaal $16,5 miljard aan teruggewonnen activa.</p>
<p>Deze beslissing markeert een aanzienlijke vooruitgang in de terugbetalingen voor FTX-crediteuren sinds de ineenstorting in november 2022.</p>
<p>Volgens het plan zal FTX prioriteit geven aan het dekken van 98% van de gebruikers binnen 60 dagen nadat het faillissementsplan van kracht wordt, specifiek schuldeisers wiens accountactiva ≤ $50.000 waren ten tijde van het faillissement.</p>
<h2 id="h2-Kerngegevens20van20het20Vergoedingsplan973781"><a name="Kerngegevens van het Vergoedingsplan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kerngegevens van het Vergoedingsplan</h2><ul>
<li>Compensatiebedrag en tijdlijn: De totale waarde van de activa die beschikbaar zijn voor compensatie van FTX ligt tussen de $14,5 miljard en $16,3 miljard. De compensatie zal gefaseerd plaatsvinden: ongeveer $1,1 miljard zal tegen het einde van 2024 aan 98% van de gebruikers worden betaald, met het resterende bedrag dat uiterlijk in Q2 2025 zal worden afgerond.</li><li>Compensatiestandaard: Gebaseerd op de dollarwaarde van vorderingen op het moment van faillissement in november 2022. Kleine crediteuren (≤ 50.000 USD) ontvangen 118%, terwijl grote crediteuren 100% + rentecompensatie ontvangen.</li><li>Controversy Focus: Sommige schuldeisers eisen compensatie in fysieke vorm (oorspronkelijke valuta), tegen de schikking op basis van de waarde van de dollar in 2022. Bijvoorbeeld, de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> was op dat moment slechts $16.000, maar momenteel (juni 2025) is het meer dan $110.000. Echter, de rechtbank ondersteunt contante compensatie, aangezien FTX een enorme activetekortkoming heeft (slechts 0,1% BTC over, 1,2% ETH over), en fysieke compensatie zou vereisen dat er munten op de markt worden gekocht, wat “belachelijk duur” is.</li></ul>
<h2 id="h2-Huidige20Compensatievoortgang20en20Gebruikerscategorien564592"><a name="Huidige Compensatievoortgang en Gebruikerscategorieën" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige Compensatievoortgang en Gebruikerscategorieën</h2><ul>
<li>Ingangsdatum van het plan: Oorspronkelijk verwacht op 31 oktober 2024 van kracht te worden, maar vanwege de complexiteit van het proces zullen sommige betalingen worden vertraagd tot begin 2025.</li><li><p>Prioriteitscompensatiegroep:</p>
<ul>
<li>Klasse 7A: Gebruikers met een schuld ≤ $50.000 genieten een prioriteitsaflossingspercentage van 120,5% (inclusief rente). Een bepaald geval toont aan dat het op 18 februari 2025 werd toegewezen.</li><li>Klas 5A: Gebruikers met schulden groter dan $50.000 moeten wachten op de volgende batches.</li></ul>
</li><li>Creditor attitude: 94,48% van de schuldeisers (totaal vorderingsbedrag van $6,83 miljard) stemde in het voordeel van het plan. Tegenstanders maken zich echter zorgen dat contante compensatie kan leiden tot aanzienlijke belastingkosten.</li></ul>
<h2 id="h2-Claim20Operation20Gids20Vijfstappenproces792676"><a name="Claim Operation Gids (Vijf-stappenproces)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Claim Operation Gids (Vijf-stappenproces)</h2><p>In maart 2024 zal PwC het claimsportaal van FTX Digital Markets activeren als gezamenlijke curator, en gebruikers moeten vóór de deadline van 15 mei 2024 elektronische claimsregistratie voltooien:</p>
<ol>
<li>Accountregistratie: Geef informatie zoals naam, telefoonnummer, e-mailadres, datum van opening van de rekening, enz., en kies het type aanvrager (individu/institutie/non-klant schuldeiser).</li><li><a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">Link</a> FTX-account: Vul identiteitsinformatie in (paspoort/ID-nummer), <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> het oorspronkelijke FTX-account e-mailadres en verifieer de machtigingen.</li><li>Bevestig of betwist saldo: Controleer de accountsaldo-gegevens die door het systeem worden weergegeven. Als er een geschil is, moet u bewijsdocumenten uploaden (zoals positiegegevens, transactie-schermafbeeldingen, enz.).</li><li>Identiteitsverificatie (KYC/AML): De clearing agent controleert de identiteitsdocumenten op de achtergrond en meldt de gebruiker per e-mail zodra deze is goedgekeurd.</li><li>Wachten op liquidatieallocatie: betalingen worden in batches gedaan nadat het oordeel is voltooid, met de eerste allocatie die gepland staat om te beginnen aan het einde van 2024 tot het begin van 2025.</li></ol>
<h2 id="h2-Veelgestelde20Vragen20en20Risicowaarschuwingen892685"><a name="Veelgestelde Vragen en Risicowaarschuwingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde Vragen en Risicowaarschuwingen</h2><ul>
<li>“Betwiste Schuldeis”: Dit kan optreden als gevolg van dubbele verklaringen, discrepanties in houdingsrecords of jurisdictieconflicten (zoals die met Liquid Global-gebruikers in Singapore). Dergelijke claims kunnen nog steeds worden aangevochten en, bij goedkeuring, kunnen zij latere toewijzingen ontvangen.</li><li>Verwachtingen voor Kapitaal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> Terug naar de markt: Ongeveer 50% van de oorspronkelijke schuldeisen is overgedragen aan professionele instellingen, en sommige fondsen keren mogelijk niet terug naar de cryptomarkt. Analist Su Zhu gelooft echter dat de vrijgave van tientallen miljarden aan fondsen de markt nog steeds kan aandrijven.</li><li>Beveiligingswaarschuwing: Pas op voor phishing-e-mails en voer alleen handelingen uit via het officiële FTX-claimsportaal (verificatie met twee-factor-authenticatie vereist).</li></ul>
<p>Vanaf februari 2025 hebben enkele Class 7A-gebruikers 120,5% terugbetaling ontvangen (inclusief rente). Voor gebruikers wiens schuldenstatus “betwist” aangeeft, is het liquidatieteam nog steeds bezig met activa-reconciliatie en coördinatie van rechtsgebieden, waarbij de uiteindelijke toewijzing of voortzetting zich uitstrekt tot het midden van de late 2025.</p>
<p>Voor eisers die niet op tijd indienen, kunnen sommige rechtsgebieden aanvullende kanalen openen, maar de terugvorderingsratio van de fondsen zal aanzienlijk worden verminderd. Deze tweeënhalf jaar durende faillissementsliquidatie komt ten einde met miljarden aan contante liquiditeit, wat het einde markeert van het donkerste hoofdstuk in de geschiedenis van cryptocurrency.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U moet altijd onafhankelijk professioneel advies inwinnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>