Q2Vsc2l1cyBvbnRncmVuZGVsdCBkdWl6ZW5kZW4gRXRoZXIgaW4gbW9nZWxpamtlIHZlcmxpY2h0aW5nIHZhbiBFVEggdmVya29vcGRydWs=

2024-01-17, 08:14

<p><img src="https://gimg2.gateimg.com/image/article/1705476002SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen681000"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Celsius is van plan om 206.300 ETH te ontgrendelen om te herverdelen aan crediteuren.<br>Het ontgrendelen van 206.300 ETH kan de verkoopdruk van de munt verhogen, waardoor de prijs daalt.</p>
<p>Na goedkeuring van de spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s de prijs van ETH is gestegen.</p>
<h2 id="h2-Introductie213787"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In 2023 zullen verschillende crypto-projecten, waaronder FTX en <a href="https://www.gate.io/blog_detail/1339/celsius-filed-a-bankruptcy-claim-in-new-york" target="_blank">Celsius werd insolvent en vroeg faillissement aan</a>. Het kost echter vaak tijd om het faillissementsproces op te starten, afhankelijk van of het insolvente bedrijf al dan niet wil herstructureren. Zoals de zaken er nu voor staan, streeft Celsius naar herstructurering.</p>
<p>Deze post richt zich op de herstructurering van het faillissement van Celsius en de schuldsanering. We zullen ook kijken naar de effecten van de ontgrendeling van ETH door Celsius op de prijs.</p>
<h2 id="h2-Het20ETH20Unstaking20Plan20van20Celsius20wint20aan20momentum485744"><a name="Het ETH Unstaking Plan van Celsius wint aan momentum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het ETH Unstaking Plan van Celsius wint aan momentum</h2><p><a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a>, de failliete crypto-uitlener, heeft onlangs aangekondigd dat het binnenkort een aanzienlijke hoeveelheid ETH zal ‘unstaken’ om de herverdeling van activa aan zijn schuldeisers te vergemakkelijken. Deze stap maakt deel uit van het herstructureringsproces en een weg om zijn uitstaande verplichtingen te voldoen.</p>
<p>Het bedrijf wil fondsen werven om de uitdagingen aan te pakken waarmee het wordt geconfronteerd, waaronder hoge kosten die zijn gemaakt tijdens de herstructureringsfase. De financiële problemen zijn verergerd in juli 2022 nadat het faillissement volgens hoofdstuk 11 werd aangevraagd.</p>
<p>Op 4 januari kondigde het bedrijf aan dat het <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">plan om Ether te ontgrendelen</a>. Het zei: “Celsius zal bestaande ETH-posities ontgrendelen, die waardevolle beloningsinkomsten voor het domein hebben opgeleverd, om bepaalde kosten te compenseren die zijn gemaakt tijdens het herstructureringsproces.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705477021Celsius 1.png" alt=""><br>Bron: x.com</p>
<p>Het vervolgde: ‘Ter voorbereiding op eventuele vermogensverdelingen is Celsius begonnen met het proces van terughalen en herbalanceren van activa om voldoende liquiditeit te waarborgen. Celsius zal bestaande ETH-posities ontkapitaliseren, die waardevolle inkomsten uit stakingsbeloningen hebben opgeleverd voor het landgoed, om bepaalde kosten te compenseren die tijdens het herstructureringsproces zijn gemaakt.’</p>
<p>Celsius was duidelijk in zijn aankondiging dat het van plan is om zijn schuldeisers af te betalen. Zo legde het uit: ‘Zoals herinnerd, zullen in aanmerking komende schuldeisers in natura distributies van BTC en ETH ontvangen zoals uiteengezet in het goedgekeurde Plan.’ Volgens zijn <a href="https://twitter.com/CelsiusNetwork/status/1743023398349930623?s=20" rel="nofollow noopener noreferrer" target="_blank">post op X</a> Het bedrijf heeft meer dan 6.700 schuldeisers.</p>
<p>De <a href="https://query.nansen.ai/public/dashboards/Hk93n66vsO0uvycfui8ypF2xcpNhpraxfwX5AWZJ" rel="nofollow noopener noreferrer" target="_blank">Nansen-dashboard</a> Toont aan dat Celsius 206.300 ETH heeft, ter waarde van ongeveer $470 miljoen, die nog moeten worden ingezet. De volgende diagram toont de verdeling van niet-ingezette ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705477042Celsius 2.png" alt=""><br>De verdeling van niet-ingeschreven ETH - Nansen</p>
<p>Zoals het diagram laat zien, bezit Celsius ongeveer 32% van alle niet-uitgezette ETH. Omdat het van plan is ETH te verkopen, kan dit van invloed zijn op de prijs. Opnieuw heeft het bedrijf sinds 2023 40.249 ETH teruggetrokken.</p>
<p>Hoewel het herstructureringsproces van Celsius goed verloopt, hebben sommige crediteuren kritiek geuit op het bedrijf omdat het geen exacte datum heeft gegeven voor de distributie van crypto-activa. De volgende schermafbeelding toont een recente opmerking met betrekking tot de distributie van ETH en andere cryptocurrencies door Celsius.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705479022Celsius 3.png" alt=""><br>Crediteuren roepen op tot een distributiedatum - xDigitalAssetupd</p>
<p>De rechtbank heeft al een herstructureringsplan goedgekeurd waarbij de schuldeisers tot 79% van hun cryptobezit zullen terugkrijgen. Volgens het plan zal Celsius zowel <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> als ETH aan zijn schuldeisers uitdelen. Het volgende diagram toont Celsius Crypto Holding.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705479044Celsius 4.png" alt=""><br>Celsius Crypto Holding – XCelsius</p>
<p>Zoals u kunt zien in de tabel heeft Celsius verschillende crypto-activa zoals BTC, ETH, CEL, Matic en USDC. Ondertussen heeft de rechtbank geselecteerde gebruikers toegestaan om een deel van de crypto-activa op te nemen tot 28 februari.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/the-risk-for-cryptocurrency-you-should-know/90" target="_blank">Risico’s waar u zich bewust van moet zijn bij het handelen in crypto</a></p>
<h2 id="h2-Factoren20die20bijdragen20aan20negatieve20sentimenten20over20Ether287965"><a name="Factoren die bijdragen aan negatieve sentimenten over Ether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Factoren die bijdragen aan negatieve sentimenten over Ether</h2><p>De cryptogemeenschap heeft gemengde gevoelens over het opnemen van een grote hoeveelheid ETH door Celsius, omdat dit invloed kan hebben op de prijs. Sommige analisten hebben gezegd dat het verkopen van veel ETH in één keer of binnen een zeer korte periode kan leiden tot hoge verkoopdruk, wat kan leiden tot een daling van de prijs van ETH.</p>
<p>Sommige analytische grafieken geven een mogelijkheid van een scherpe <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> dalend tot onder $1.895, wat een kritiek ondersteuningsniveau is. Die scherpe prijsdaling kan alleen worden voorkomen als er een dramatische stijging is in het aantal investeerders dat bereid is ETH te kopen. De marktsentiment zal waarschijnlijk ook de richting beïnvloeden die de ETH-prijs zal nemen na de verkoop en herverdeling.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-ethereum-2-0/102" target="_blank">Wat is Ethereum 2.0? Het samenvoegen begrijpen</a></p>
<p>In december, <a href="https://cryptoslate.com/celsius-sold-off-250-million-in-eth-and-other-assets-in-30-days/" rel="nofollow noopener noreferrer" target="_blank">CryptoSlate meldde</a> dat de crypto-uitlener cryptocurrencies ter waarde van $250 miljoen heeft verkocht binnen 30 dagen. Zoals opgemerkt, terwijl andere institutionele beleggers ervoor kiezen om ETH te staken, maakt Celsius zijn staking ongedaan en verkoopt het grootste deel van zijn bezittingen.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/pt/blog_detail/2026/brace-for-impact-a-guide-to-navigating-a-cryptocurrency-crash-in-2023" target="_blank">Een handleiding voor het navigeren van een cryptocurrency-crash in 2023</a></p>
<p>Bovendien kunnen sommige crediteuren de munt verkopen wanneer Celsius deze eindelijk aan hen distribueert, wat de ETH-prijs kan doen dalen. Dit komt doordat het aanbod zal toenemen terwijl slechts weinig investeerders er klaar voor zullen zijn. <a href="/how-to-buy/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">koop Ethereum</a>. Sommige waarnemers hebben gesuggereerd dat Celsius een deel van zijn crypto-activa verkoopt om geld in te zamelen voor investeringen in bitcoin-mining.</p>
<p>Een x.com gebruiker met de naam <a href="https://twitter.com/Carlini8NFT/status/1743033701779271999" rel="nofollow noopener noreferrer" target="_blank">@Carlini8NFT</a> heeft de actie van Celsius beschreven als het dompelen van ETH op de markt, wat wijst op een mogelijke negatieve invloed op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> prijs.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705479079Celsius 5.png" alt=""><br>Crypto Degens kunnen ETH in grote hoeveelheden kopen - X@Carlini8NFT</p>
<p>Ondanks de huidige onzekerheid op de Ethereum-markt denken sommige analisten dat de beslissing van Celsius om ETH niet meer in te zetten een positieve ontwikkeling is. Een dergelijke beslissing zal verlichting brengen voor haar crediteuren, die hun ETH-bezit op de gewenste manier kunnen gebruiken. Sommigen van hen kunnen er zelfs voor kiezen om ETH in te zetten.</p>
<p>Op x zei @Wazzycrypto: “Ik denk niet dat jullie begrijpen hoeveel gewicht er van $ETH zal worden afgenomen wanneer de Celsius-vampiers eindelijk ‘verdwijnen’ en herverdelen wat er overblijft. Ze hielden meer dan $800M $ETH vast, waren een van de grootste stakers en hebben maandenlang consequent $20M/week op de markt verkocht.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705479103Celsius 6.png" alt=""><br>Bron: x.com</p>
<p>Hoewel er veel negatieve sentiment is over ETH op basis van de aanstaande grootschalige ETH unstaking, zijn er verschillende factoren die ook de prijs ervan kunnen opdrijven. Na de goedkeuring van meerdere spot bitcoin ETF’s steeg de prijs van ETH en Ethereum-gebaseerde tokens. De reden hiervoor is dat de markt nu verwacht dat de SEC spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s zal goedkeuren.</p>
<p>Ten tweede werd het voorstel van Vitalik Buterin, mede-oprichter van Ethereum, om de gaslimiet van Ethereum te verhogen goed ontvangen op de markt, wat resulteerde in <a href="https://www.gate.io/price/ethereum-eth" target="_blank">recente stijging van de ETH-prijs</a>. De ontwikkelingen hebben een podium gecreëerd voor meer investeerders om ETH te kopen, wat de prijs kan opdrijven.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">SEC keurt Ethereum Futures ETFS goed</a></p>
<p><a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">hbar crypto</a></p>
<p>Als onderdeel van haar herstructureringsproces zal Celsius binnenkort haar ETH-inzet ontgrendelen om het te verdelen onder crediteuren en om fondsen te werven om haar kosten te dekken. Sommige analisten geloven echter dat het ontgrendelen van ETH zal resulteren in een aanzienlijke daling van de prijs. Aan de andere kant zijn er andere factoren zoals de voorgestelde verhoging van de Ethereum gaslimiet en de kans op de <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">SEC keurt spot ETH ETF’s goed</a> kan de prijs van de munt stabiliseren.</p>
<h2 id="h2-Veelgestelde20vragen20over20Celsius767462"><a name="Veelgestelde vragen over Celsius" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Celsius</h2><h3 id="h3-Wat20is20Celsius329569"><a name="Wat is Celsius?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Celsius?</h3><p>Celsius is een wettelijk leningplatform dat gebruikers in staat stelt rente te verdienen op de cryptocurrencies die ze erbij storten. Celsius ondergaat echter herstructurering sinds het in juli 2022 faillissement heeft aangevraagd onder hoofdstuk 11.</p>
<h3 id="h3-Waarom20ging20Celsius20failliet62137"><a name="Waarom ging Celsius failliet?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom ging Celsius failliet?</h3><p>De ineenstorting van <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD veroorzaakte financiële beperkingen voor Celsius vanwege het besmettingseffect. Specifiek had het bedrijf een tekort van $1,2 miljard nadat het een digitale versie van een bankrun had ondergaan. De belangrijkste oorzaken van de run waren een langdurige cryptowinter en vijandige mediaverslaggeving.</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 standpunten 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 is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>