RmFsbGltZW50aSBjcmlwdGF0aTogS2lya2xhbmQgJiBFbGxpcyBnYXJhbnRpc2NlICQxMjAgbWlsaW9uaSBuZWkgY2FzaSBkaSBDZWxzaXVzLCBDb3JlIFNjaWVudGlmaWMsIEJsb2NrRmksIFZveWFnZXI=

2024-01-31, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR753064"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Celsius ha guadagnato un totale di $120 milioni per rappresentare Celsius, Core Scientific, BlockFi e Voyager nei loro casi di fallimento.</p>
<p>Celsius ha pagato più della metà dei 120 milioni di dollari poiché il suo caso era più complesso rispetto a quelli di Core Scientific, BlockFi e Voyager.</p>
<p>Nel contesto del processo di ristrutturazione, Celsius ha offerto un accordo ai detentori di grandi conti.</p>
<h2 id="h2-Introduzione996748"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Alcune delle procedure legali dei casi di bancarotta che sono occorsi nel 2022 e nel 2023 sono ancora in corso. La maggior parte delle aziende ha presentato istanza di fallimento ai sensi del capitolo 11, mentre altre hanno optato per il capitolo 7. Per motivi di celerità, la maggior parte di queste aziende ha assunto studi legali specializzati come Kirkland &amp; Ellis per rappresentarle. Tuttavia, la maggior parte di questi studi legali addebita tariffe elevate.</p>
<p>In questo caso, vediamo quanto Kirkland &amp; Ellis ha incassato per rappresentare Celsius, Core Scientific, BlockFi e Voyager. Esploreremo anche come queste aziende hanno proceduto con le loro diverse procedure legali di fallimento.</p>
<p>Notizie recenti: <a href="https://www.gate.io/zh/blog_detail/1627/compute-north-perusahaan-penambangan-bitcoin-mengajukan-kebangkrutan-bab-11" target="_blank">Compute North, una società di mining di Bitcoin, presenta istanza di fallimento ai sensi del Capitolo 11</a></p>
<h2 id="h2-Kirkland20amp20Ellis20guadagna2012020milioni20nei20casi20di20Celsius20Core20Scientific20BlockFi20e20Voyager505070"><a name="Kirkland &amp; Ellis guadagna $120 milioni nei casi di Celsius, Core Scientific, BlockFi e Voyager" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kirkland &amp; Ellis guadagna $120 milioni nei casi di Celsius, Core Scientific, BlockFi e Voyager</h2><p>Negli ultimi due anni alcune società legali hanno guadagnato rappresentando società criptate che hanno dichiarato bancarotta volontaria. Alcune di queste società criptate hanno chiesto il fallimento con l’intenzione di ristrutturare, mentre altre miravano a liquidare le loro attività.</p>
<p>Il motivo principale per cui diverse società criptate hanno dichiarato bancarotta nella cripto nel 2022 è stato il crollo della cripto che è avvenuto durante l’inverno cripto. Inoltre, diverse borse cripto <a href="https://www.gate.io/blog_detail/3299/bitmain-to-inject-dollar54-million-into-bankrupt-bitcoin-mining-firm-core-scientific" target="_blank">entrato in bancarotta del Capitolo 11</a> che ha aggravato la situazione disperata nel settore.</p>
<p>Kirkland &amp; Ellis è un grande studio legale, con molta competenza nella rappresentazione di aziende fallite negli Stati Uniti. Dal 2022 offre i suoi servizi legali a <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 e Voyager Digital <a href="https://www.gate.io/blog_detail/1339/celsius-filed-a-bankruptcy-claim-in-new-york" target="_blank">nei loro procedimenti legali di fallimento</a>.</p>
<p>Come per un <a href="https://news.bloomberglaw.com/business-and-practice/kirkland-nets-120-million-in-celsius-blockfi-voyager-work" rel="nofollow noopener noreferrer" target="_blank">rapporto di Bloomberg</a>, Kirkland &amp; Ellis ha guadagnato più di $120 milioni in onorari legali per aver rappresentato le tre aziende. Il rapporto ha inoltre dichiarato che Kirkland &amp; Ellis addebita $1,995 all’ora per i servizi offerti alle tre società di criptovalute. In confronto, questa è una delle tariffe più alte del settore.</p>
<p>Approssimativamente, ogni una di queste società di criptovalute potrebbe aver pagato circa 3,3 milioni di dollari al mese. Tuttavia, i clienti di Kirkland &amp; Ellis non avevano opzioni poiché la complessità dell’industria delle criptovalute richiede competenze legali specializzate per valutare i possibili rischi e ricompense.</p>
<p>Una cosa interessante è che le spese stabiliti dagli studi legali per ogni singolo caso sono approvate dal tribunale fallimentare. Ciò significa che nei casi di <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a>, BlockFi e Voyager Digital, il fallimento 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> Il tribunale ha approvato le strutture delle spese legali.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/celsius-network-cel" target="_blank">Previsione del prezzo di Celsius Network (CEL) 2024-2030</a></p>
<p>In modo significativo, le commissioni da sole da Celsius ammontano a $76 milioni che è molto più alto di quello di <a href="https://www.gate.io/learn/articles/what-is-vgx/560" target="_blank">Voyager</a> e <a href="https://www.gate.io/blog_detail/1241/will-blockfi-be-the-next-to-fall" target="_blank">Casi BlockFi</a>, che ammontano rispettivamente a $27 milioni e $16 milioni.</p>
<p>Il caso Celsius è piuttosto complesso in quanto coinvolgeva accuse contro Alex Mashinsky, il suo ex CEO. Tuttavia, Kirkland &amp; Ellis ha negoziato con successo un accordo permettendo a Celsius di lanciare un’operazione di mining di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di proprietà dei creditori al momento dell’uscita dalla bancarotta.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3647/safemoon-bankruptcy" target="_blank">SafeMoon avvia il fallimento del capitolo 7, SFM crolla del 42%</a></p>
<h2 id="h2-Celsius20Network20offre20un20regolamento20ai20grandi20detentori20di20conti589959"><a name="Celsius Network offre un regolamento ai grandi detentori di conti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Celsius Network offre un regolamento ai grandi detentori di conti</h2><p>In un’altra evoluzione, Celsius ha ottenuto un altro successo raggiungendo un accordo con i suoi grandi detentori di conti. I grandi detentori di conti sono stati invitati a saldare i loro obblighi finanziari entro il 31 gennaio 2024.</p>
<p>Ciò si applica ai grandi titolari di conti con esposizione di preferenza di prelievo. In altre parole, la liquidazione si applica a coloro che hanno effettuato grandi trasferimenti entro 90 giorni prima della data della richiesta, il 13 luglio 2022. Questa condizione è un elemento importante del Piano di Riorganizzazione Modificato del Capitolo 11 congiunto.</p>
<p>In termini semplici, questo regolamento si applica ai titolari di conto che hanno un’esposizione che supera i $100.000. Tutti gli investitori in criptovalute che desiderano regolare dovrebbero inviare il modulo di elezione entro il 25 gennaio 2024. Dovrebbero inoltre effettuare il pagamento di regolamento entro il 31 gennaio.</p>
<p>D’altra parte, i titolari di un conto Celsius con un’esposizione inferiore a $100.000 non dovrebbero intraprendere alcuna azione. Tuttavia, coloro che non effettueranno il pagamento entro il 31 gennaio saranno passibili di azioni legali da parte dell’Amministratore della Controversia Legale.</p>
<h2 id="h2-BlockFi20esce20dal20fallimento524340"><a name="BlockFi esce dal fallimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlockFi esce dal fallimento</h2><p>BlockFi, che ha dichiarato il fallimento delle criptovalute nel novembre 2022, è uscito dal fallimento. Ora cerca di recuperare i fondi che FTX, Three Arrows Capital e altre società gli devono.</p>
<p>Inoltre, l’azienda conferma che continuerà a distribuire attività criptografiche ai propri clienti. Durante l’ultimo trimestre del 2023, BlockFi ha riconciliato le attività che i clienti hanno rivendicato. Nello stesso periodo, alcuni clienti sono riusciti a prelevare le proprie attività. Tutto ciò di cui avevano bisogno era inviare le loro richieste di prelievo.</p>
<h2 id="h2-Il20rimbalzo20di20Bitcoin20allevia20la20riorganizzazione20del20fallimento20di20Core20Scientific519332"><a name="Il rimbalzo di Bitcoin allevia la riorganizzazione del fallimento di Core Scientific" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il rimbalzo di Bitcoin allevia la riorganizzazione del fallimento di Core Scientific</h2><p>Core Scientific, la società di mining di criptovalute, ha ottenuto l’approvazione del tribunale per uscire dal fallimento delle criptovalute e procedere con il processo di ristrutturazione che riduce il debito di $400 milioni dal suo bilancio. Utilizzerà tale importo per ripagare i creditori.</p>
<p>Grazie alla svolta nel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> la società può permettersi di pagare i suoi creditori. Attraverso un comunicato stampa, l’azienda ha evidenziato <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’aumento recente del prezzo di ‘s come un fattore contributivo alla sua stabilità finanziaria.</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">È stato pubblicato</a>“Con la domanda di Bitcoin e computer ad alto valore in continuo aumento, siamo fiduciosi di creare valore per i nostri azionisti mentre attuiamo il nostro piano di crescita, riduciamo l’indebitamento del nostro bilancio e offriamo un’efficienza superiore su larga scala.”</p>
<p>In uno sviluppo correlato, l’azienda ha accennato che le sue azioni potrebbero essere rilistate entro la fine di gennaio. Nel piano di riorganizzazione, gli azionisti di Core Scientific otterranno il 60% del suo nuovo patrimonio netto.</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">Nella nota stampa Core Scientific ha detto</a>, “Assumendo l’esercizio in contanti di tutte le opzioni esercitabili, e che il denaro venga utilizzato per ripagare il debito, il debito esistente della società verrebbe pagato integralmente, con una riduzione di circa 1 miliardo di dollari rispetto al saldo del debito precedente al Piano.”</p>
<p>Inoltre, <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 di Core Scientific, ha detto</a>, “La conferma del piano di oggi è un momento decisivo nella nostra riorganizzazione; siamo pronti a emergere entro la fine di questo mese come un’azienda ancora più forte, con un team altamente motivato e allineato al successo.” Come indicato, Core Scientific si propone di riposizionarsi in modo deciso entro l’inizio di febbraio.</p>
<h2 id="h2-Conclusione464662"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il calo dei prezzi delle criptovalute del 2022 ha portato molti vincoli finanziari tra alcune società di criptovalute. Purtroppo, alcune di queste società di criptovalute hanno chiuso mentre altre hanno dichiarato bancarotta con l’obiettivo di ristrutturarsi. Celsius, Core Scientific, BlockFi e Voyager sono alcuni esempi di società di criptovalute che hanno dichiarato bancarotta nel 2022. Di conseguenza, Kirkland &amp; Ellis ha offerto loro servizi legali, ma a un costo elevato.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em> Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno adottate azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>