Q3J5cHRvIEZhaWxsaXNzZW1lbnRlbjogS2lya2xhbmQgJiBFbGxpcyBCZXZlaWxpZ3QgJDEyMCBNaWxqb2VuIGluIENlbHNpdXMsIENvcmUgU2NpZW50aWZpYywgQmxvY2tGaSwgVm95YWdlciBaYWtlbg==

2024-01-31, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR12232"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Celsius heeft in totaal $120 miljoen verdiend door Celsius, Core Scientific, BlockFi en Voyager te vertegenwoordigen in hun faillissementszaken.</p>
<p>Celsius betaalde meer dan de helft van de $120 miljoen, omdat hun zaak ingewikkelder was dan die van Core Scientific, BlockFi en Voyager.</p>
<p>Als onderdeel van het herstructureringsproces heeft Celsius een schikking aangeboden aan grote rekeninghouders.</p>
<h2 id="h2-Introductie83308"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sommige van de juridische procedures van faillissementszaken die plaatsvonden in 2022 en 2023 zijn nog steeds gaande. De meeste bedrijven hebben zich failliet verklaard volgens hoofdstuk 11 van de faillissementswet, terwijl anderen hoofdstuk 7 kozen. Voor de snelheid hebben de meeste van deze bedrijven gespecialiseerde advocatenkantoren zoals Kirkland &amp; Ellis ingehuurd om hen te vertegenwoordigen. Desalniettemin rekenen de meeste van deze juridische kantoren hoge kosten.</p>
<p>In dit g bekijken we hoeveel Kirkland &amp; Ellis heeft binnengehaald voor het vertegenwoordigen van Celsius, Core Scientific, BlockFi en Voyager. We zullen ook onderzoeken hoe deze bedrijven zijn voortgegaan met hun verschillende faillissementsprocedures.</p>
<p>Recent nieuws: <a href="https://www.gate.io/zh/blog_detail/1627/compute-north-perusahaan-penambangan-bitcoin-mengajukan-kebangkrutan-bab-11" target="_blank">Compute North, een Bitcoin Mining-bedrijf, dient een verzoek in voor faillissement van hoofdstuk 11</a></p>
<h2 id="h2-Kirkland20amp20Ellis20verdient2012020miljoen20in20Celsius20Core20Scientific20BlockFi20en20Voyager20zaken529412"><a name="Kirkland &amp; Ellis verdient $120 miljoen in Celsius, Core Scientific, BlockFi en Voyager zaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kirkland &amp; Ellis verdient $120 miljoen in Celsius, Core Scientific, BlockFi en Voyager zaken</h2><p>In de afgelopen twee jaar hebben sommige advocatenkantoren geprofiteerd van het vertegenwoordigen van crypto-bedrijven die vrijwillig faillissement hebben verklaard. Sommige van deze crypto-bedrijven hebben faillissement aangevraagd met de bedoeling te herstructureren, terwijl anderen hun bedrijven wilden opdoeken.</p>
<p>De belangrijkste reden waarom verschillende crypto-bedrijven in 2022 failliet gingen in de cryptowereld, was de cryptodaling die plaatsvond tijdens de cryptowinter. Bovendien zijn er verschillende crypto-beurzen <a href="https://www.gate.io/blog_detail/3299/bitmain-to-inject-dollar54-million-into-bankrupt-bitcoin-mining-firm-core-scientific" target="_blank">betrad Hoofdstuk 11 faillissement</a> wat de ernstige situatie in de sector verergerde.</p>
<p>Kirkland &amp; Ellis is een groot advocatenkantoor, met veel expertise in het vertegenwoordigen van failliete bedrijven in de Verenigde Staten. Sinds 2022 biedt het zijn juridische dienstverlening aan. <a href="https://www.gate.io/blog_detail/1212/what-is-celsius-network-cel-tradfi-and-defi-meet-and-recent-controversies" target="_blank">Celsius Network</a>, BlockFi en Voyager Digital <a href="https://www.gate.io/blog_detail/1339/celsius-filed-a-bankruptcy-claim-in-new-york" target="_blank">in hun faillissementsprocedures</a>.</p>
<p>Zoals per een <a href="https://news.bloomberglaw.com/business-and-practice/kirkland-nets-120-million-in-celsius-blockfi-voyager-work" rel="nofollow noopener noreferrer" target="_blank">Bloomberg rapport</a>, Kirkland &amp; Ellis verdiende meer dan $120 miljoen aan juridische kosten voor het vertegenwoordigen van de drie bedrijven. Het rapport vermeldde ook dat Kirkland &amp; Ellis $1.995 per uur in rekening brengt voor de diensten die het aan de drie cryptobedrijven heeft aangeboden. Dit is vergelijkenderwijs een van de hoogste tarieven in de branche.</p>
<p>Ruw geschat zou elk van deze cryptobedrijven ongeveer $3,3 miljoen per maand hebben betaald. Desalniettemin hadden de klanten van Kirkland &amp; Ellis geen andere optie, aangezien de complexe aard van de cryptobranche gespecialiseerde juridische expertise vereist om de mogelijke risico’s en beloningen af te wegen.</p>
<p>Een interessant feit is dat de tarieven die de juridische bedrijven vaststellen voor elk individueel g worden goedgekeurd door de faillissementsrechtbank. Het betekent dat in de glen van <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a>, BlockFi en Voyager Digital, het faillissement c <a href="https://www.gate.io/learn/articles/what-is-vgx/560" target="_blank">https://www.gate.io/learn/articles/what-is-vgx/560</a> Onze rechtbank heeft de juridische vergoedingsstructuren goedgekeurd.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/celsius-network-cel &quot;Celsius Network (CEL" rel="nofollow noopener noreferrer" target="_blank">Celsius Network (CEL) Prijsvoorspelling 2024-2030</a> Prijsvoorspelling 2024-2030)</p>
<p>Belangrijker nog is dat de kosten van Celsius alleen al $76 miljoen bedragen, wat veel hoger is dan dat van <a href="https://www.gate.io/learn/articles/what-is-vgx/560" target="_blank">Voyager</a> en <a href="https://www.gate.io/blog_detail/1241/will-blockfi-be-the-next-to-fall" target="_blank">BlockFi-glen</a>, die respectievelijk $27 miljoen en $16 miljoen bedragen.</p>
<p>De zaak Celsius is vrij complex omdat het beschuldigingen tegen Alex Mashinsky, zijn voormalige CEO, betreft. Kirkland &amp; Ellis heeft echter succesvol onderhandeld over een schikking en Celsius in staat gesteld een Bitcoin-mijnbouwoperatie in handen van crediteuren te starten wanneer het faillissement wordt beëindigd.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3647/safemoon-bankruptcy" target="_blank">SafeMoon start faillissementsprocedure hoofdstuk 7, SFM daalt met 42%</a></p>
<h2 id="h2-Celsius20Network20biedt20schikking20aan20grote20accounthouders825267"><a name="Celsius Network biedt schikking aan grote accounthouders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Celsius Network biedt schikking aan grote accounthouders</h2><p>In een andere ontwikkeling heeft Celsius opnieuw een doorbraak bereikt door een schikking te treffen met zijn grote rekeninghouders. De grote rekeninghouders zijn opgeroepen om hun financiële verplichtingen af te lossen tegen 31 januari 2024.</p>
<p>Dit is van toepassing op de grote rekeninghouders met Withdrawal Preference Exposure. Met andere woorden, de regeling is van toepassing op degenen die grote transfers hebben gedaan binnen 90 dagen voor de Petition Date, 13 juli 2022. Deze voorwaarde is een belangrijk element van het gewijzigde gezamenlijke hoofdstuk 11-herstructureringsplan.</p>
<p>In eenvoudige bewoordingen is deze regeling van toepassing op rekeninghouders die een blootstelling hebben van meer dan $100.000. Alle crypto-investeerders die willen schikken, moeten hun verkiezingsformulier indienen vóór 25 januari 2024. Ze moeten ook hun schikkingsbetaling doen vóór 31 januari.</p>
<p>Aan de andere kant moeten Celsius-accounthouders met een blootstelling van minder dan $100.000 geen actie ondernemen. Toch zullen degenen die de betaling niet doen vóór 31 januari aansprakelijk zijn voor juridische stappen van de Litigation Administrator.</p>
<h2 id="h2-BlockFi20verlaat20faillissement15802"><a name="BlockFi verlaat faillissement" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlockFi verlaat faillissement</h2><p>BlockFi, dat in november 2022 faillissement heeft aangevraagd voor crypto, is uit het faillissement getreden. Nu probeert het de fondsen te herstellen die het tegoed heeft van FTX, Three Arrows Capital en andere bedrijven.</p>
<p>Bovendien bevestigt het bedrijf dat het doorgaat met het uitkeren van cryptoactiva aan zijn klanten. Tijdens het laatste kwartaal van 2023 heeft BlockFi de activa waarvan de klanten aanspraak maakten verzoend. Binnen dezelfde periode konden sommige klanten hun activa opnemen. Alles wat ze hoefden te doen, was hun opnameverzoeken indienen.</p>
<h2 id="h2-Bitcoinherstel20vergemakkelijkt20het20faillissement20van20Core20Scientifics20reorganisatie176217"><a name="Bitcoin-herstel vergemakkelijkt het faillissement van Core Scientific’s reorganisatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin-herstel vergemakkelijkt het faillissement van Core Scientific’s reorganisatie</h2><p>Core Scientific, het crypto mining bedrijf, heeft goedkeuring van de rechtbank gekregen om uit de crypto faillissement te stappen en door te gaan met het herstructureringsproces dat zijn schuld met $400 miljoen vermindert van zijn balans. Het zal dat bedrag gebruiken om zijn crediteuren terug te betalen.</p>
<p>Dankzij de ommekeer in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> het bedrijf kan het zich veroorloven om zijn crediteuren te betalen. Via een persbericht benadrukte het bedrijf <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> recente prijsstijging als een bijdragende factor aan zijn financiële stabiliteit.</p>
<p><a href="https://investors.corescientific.com/investors/news/news-details/2024/Core-Scientific-Inc.-Plan-of-Reorganization-Confirmed-by-Bankruptcy-Court/default.aspx" rel="nofollow noopener noreferrer" target="_blank">Het is geplaatst</a>“Met de vraag naar <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en hoogwaardige computers die blijft stijgen, kijken we ernaar uit om waarde te creëren voor onze aandeelhouders terwijl we ons groeiplan uitvoeren, ons balansblad afbouwen en superieure efficiëntie op schaal leveren.”</p>
<p>In een gerelateerde ontwikkeling heeft het bedrijf aangegeven dat zijn aandelen mogelijk eind januari opnieuw genoteerd zullen worden. Onder het herstructureringsplan zullen de aandeelhouders van Core Scientific 60% van het nieuwe eigen vermogen ontvangen.</p>
<p><a href="https://investors.corescientific.com/investors/news/news-details/2024/Core-Scientific-Inc.-Plan-of-Reorganization-Confirmed-by-Bankruptcy-Court/default.aspx" rel="nofollow noopener noreferrer" target="_blank">In de persverklaring zei Core Scientific</a> Als alle toepasselijke warrants contant worden uitgeoefend en het geld wordt gebruikt om schulden af te lossen, zou de bestaande schuld van het bedrijf volledig worden betaald, wat neerkomt op een vermindering van ongeveer $1 miljard van het schuldsaldo vóór het Plan.</p>
<p>Ook, <a href="https://investors.corescientific.com/investors/news/news-details/2024/Core-Scientific-Inc.-Plan-of-Reorganization-Confirmed-by-Bankruptcy-Court/default.aspx" rel="nofollow noopener noreferrer" target="_blank">Adam Sullivan, CEO van Core Scientific, zei</a>“De bevestiging van het plan van vandaag is een bepalend moment in onze reorganisatie; We zijn klaar om tegen het einde van deze maand een nog sterker bedrijf te worden, met een zeer gemotiveerd team dat klaar is voor succes.” Zoals opgemerkt, streeft Core Scientific ernaar om zich begin februari sterk te herpositioneren.</p>
<h2 id="h2-Conclusie949077"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De prijsdaling van cryptovaluta in 2022 bracht veel financiële beperkingen met zich mee voor sommige crypto-bedrijven. Helaas moesten sommige van deze crypto-bedrijven hun deuren sluiten, terwijl andere faillissement aanvroegen met als doel herstructurering. Celsius, Core Scientific, BlockFi en Voyager zijn enkele voorbeelden van crypto-bedrijven die faillissement hebben aangevraagd in 2022. Als gevolg hiervan bood Kirkland &amp; Ellis hen juridische diensten aan, maar tegen een hoge prijs.</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 mening 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 zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>