Qml0bWFpbiBzdG9wdCAkNTQgbWlsam9lbiBpbiBmYWlsbGlldGUgQml0Y29pbi1taW5pbmdiZWRyaWpmIENvcmUgU2NpZW50aWZpYw==

2023-10-12, 08:00

<p><img src="https://gimg2.gateimg.com/image/article/1697097344RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR345693"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Bitmain zal $54 miljoen investeren in Core Scientific om het te ondersteunen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> mijnbouwbedrijf.</p>
<p>Bitmain zal eigen vermogen krijgen voor haar financiële bijdrage aan Core Scientific.</p>
<p>Core Scientific streeft ernaar levensvatbaar en efficiënt te zijn vóór de bitcoin-halvering van 2024.</p>
<h2 id="h2-Introductie177772"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bitcoin, <a href="https://www.gate.io/learn/articles/what-is-bitcoin/169" target="_blank">de eerste gedecentraliseerde valuta</a>, maakt gebruik van een proof-of-work consensusmechanisme. In dit g lossen transactiidators of mijnwerkers cryptografische puzzels op met behulp van hun rekenkracht. Desalniettemin is de kosten van het delven van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> zeer hoog, wat sommige BTC-mijnbouwbedrijven dwingt om te sluiten.</p>
<p>Vandaag bespreken we hoe Bitmain van plan is om $54 miljoen te injecteren in Core Scientific om haar activiteiten nieuw leven in te blazen. We zullen ook kijken naar factoren die ervoor zorgen dat sommige bitcoin-miningbedrijven failliet gaan.</p>
<h2 id="h2-Bitmain20gaat20Core20Scientific20helpen20om20uit20faillissement20te20komen160523"><a name="Bitmain gaat Core Scientific helpen om uit faillissement te komen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitmain gaat Core Scientific helpen om uit faillissement te komen</h2><p>Bitmain, ‘s werelds toonaangevende fabrikant van cryptocurrency mining-servers en kunstmatige intelligentie (AI) computing hardware, heeft ingestemd om $53,9 te investeren in Core Scientific, een bitcoin miningbedrijf en een leverancier van softwareoplossingen, die hun samenwerkingsrelatie zal uitbreiden. Bitmain zal efficiënte mining machines en gerelateerde apparatuur leveren aan Core Scientific om de bedrijfsvoering te verbeteren.</p>
<p>Eerder sloot Bitmain een hostingserviceovereenkomst waarbij Core Scientific zijn Bitcoin mining-servers gebruikt om zijn crypto mining-project te ondersteunen. Een woordvoerder van Bitmain zei over deze overeenkomst: “<br><strong>Core Scientific is een belangrijke bijdrager aan de kracht en stabiliteit van het Bitcoin-netwerk, en we kijken ernaar uit om nauw samen te werken met hun team om het volledige potentieel van Bitcoin te realiseren.</strong>”</p>
<p>De twee deals die Bitmain heeft met Core Scientific laten zien dat de eerste veel interesse heeft in de <a href="https://www.gate.io/blog_detail/359/understanding-cryptocurrency-mining" target="_blank">succes van de cryptominingindustrie</a> in Noord-Amerika. Max Hua, CEO van Bitmain, legde uit waarom Bitmain samenwerkt met de bitcoin miner.</p>
<p>Hij zei: “We kijken ernaar uit om onze strategische relatie met Core Scientific, onze langdurige partner in de VS, verder te verdiepen. Hun professionaliteit, integriteit en toewijding aan het succes van hun hostingklanten en aan de groei van het Bitcoin-netwerk is ongeëvenaard in de branche.”</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/250" target="_blank">Hoe gebruik je cloud mining om Bitcoin te minen met slechts één klik?</a></p>
<h2 id="h2-Belangrijke20voorwaarden20van20de20overeenkomst20tussen20Bitmain20en20Core20Scientific487759"><a name="Belangrijke voorwaarden van de overeenkomst tussen Bitmain en Core Scientific" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke voorwaarden van de overeenkomst tussen Bitmain en Core Scientific</h2><p>Het belangrijkste doel van de overeenkomst tussen Bitmain en Core Scientific is om het bitcoin-miningbedrijf te verbeteren om efficiëntie te bereiken die de groei en levensvatbaarheid bevordert.</p>
<p>Bitmain zal 27.000 Bitmain S19J XP 151 en verschillende bitcoin-mijnbouw-servers leveren. In ruil daarvoor zal Core Scientific $23,1 miljoen in contanten betalen en Core Scientific gewone aandelen ter waarde van $53,9 miljoen tegen een waarde per aandeel. De ‘per aandeel waarde’ van de aandelen zal afhangen van de bepalingen van de faillissementsrechtbank.</p>
<p>Wat betreft de overeenkomst zei Adam Sullivan, CEO van Core Scientific: ‘We zijn vereerd om onze belangrijke relatie met Bitmain uit te breiden. Samen hebben we hard gewerkt om onze branche te professionaliseren, een pad uit te stippelen voor de langetermijngroei van het Bitcoin-netwerk naarmate de adoptie van bitcoin wereldwijd toeneemt.’</p>
<p>Core Scientific en andere crypto miners nemen maatregelen om de manier waarop ze cryptocurrency delven te verbeteren vóór het volgende bitcoin-halveringsevenement. In dit verband zei Sullivan: ‘De productkwaliteit, aandacht voor service en responsiviteit van Bitmain zijn cruciaal voor ons succes in het ondersteunen van het Bitcoin-netwerk.’</p>
<p>Hij voegde eraan toe: “De nieuwe mijnwerkers die we met deze overeenkomst veiligstellen, zullen de efficiëntie van onze mijnvloot verbeteren terwijl we ons blijven voorbereiden op het halveringsevenement van volgend jaar en daarna.”</p>
<p>In feite zal de bitcoin halvering van 2024 de mijnbouw moeilijkheidsgraad verhogen, wat veel bedrijven die BTC delven, mogelijk dwingt om failliet te gaan, tenzij <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> neemt aanzienlijk toe. Er blijft echter een grote vraag: Zullen bitcoin miners failliet gaan?</p>
<h2 id="h2-Kunnen20cryptobedrijven20die20BTC20delven20failliet20gaan4997"><a name="Kunnen cryptobedrijven die BTC delven failliet gaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kunnen cryptobedrijven die BTC delven failliet gaan?</h2><p>Er bestaat geen twijfel over dat crypto mining bedrijven die op een inefficiënte manier BTC mijnen failliet kunnen gaan. De reden hiervoor is dat elke Bitcoin miner veel kosten maakt.</p>
<p>De winstniveaus die crypto-bedrijven die BTC mijnen genereren, hangen af van hun kostenstructuren en de huidige bitcoin-prijs. Als de BTC-prijs hoog is, kunnen de meeste BTC-mijnbouwbedrijven hun operationele kosten dekken en winst genereren.</p>
<p>In 2022 waren er veel cryptobedrijven actief in de <a href="https://www.gate.io/learn/articles/what-is-btc-mining/287" target="_blank">Bitcoin mijnbouwindustrie</a> gesloten vanwege hoge verliezen sinds de <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">BTC prijs</a> was erg laag als gevolg van de cryptowinter.</p>
<p>De kostenstructuren van de bitcoin miningbedrijven bepalen hun levensvatbaarheid. Afgezien van de kosten voor de aanschaf van de <a href="https://www.gate.io/learn/course/crypto-mining-equipment" target="_blank">BTC mijnbouwapparatuur</a> Dergelijke bedrijven maken veel kosten voor elektriciteit. De kosten van energie zijn waarschijnlijk de grootste uitgavenpost op de balans van de mijnbouwbedrijven.</p>
<p>De kosten van gespecialiseerde mijnbouwmachines, genaamd rigs, vormen een grote financiële last voor bedrijven die BTC delven. In veel glen lenen crypto-bedrijven geld om bitcoin-mijnbouw-servers en andere gespecialiseerde apparatuur aan te schaffen. Ze streven ernaar om met hun winst dit geld terug te betalen. Als ze echter niet genoeg winst genereren, worden ze gedwongen tot faillissement.</p>
<p>Helaas kunnen de geldschieters in sommige glen de mijnbouwapparatuur in beslag nemen, waardoor ze failliet gaan.</p>
<p>Een van de kritieke factoren die de levensvatbaarheid van cryptominers negatief beïnvloeden, is inefficiëntie. Vaak leiden verouderde en inefficiënte bitcoin-mijnbouwmachines tot hoge productiekosten, wat kan leiden tot lage winst of hoge verliezen. Daarom kunnen alleen efficiënte en kosteneffectieve bedrijven actief blijven in de BTC-mijnbouwsector.</p>
<p>Al veel bedrijven die cryptocurrency mijnen zijn al insolvent geworden en hebben faillissement aangevraagd. Compute North, een Amerikaans crypto mining bedrijf en Celsius Mining, een mijnbouweenheid van <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a> die in juli 2022 faillissement heeft aangevraagd, hebben al faillissement verklaard. Andere crypto mining bedrijven zoals Greenidge Generation Holdings hebben gewaarschuwd voor mogelijk faillissement.</p>
<h2 id="h2-Conclusie74215"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Onlangs is Bitmain een overeenkomst aangegaan om Core Scientific te voorzien van diverse apparatuur in ruil voor aandelen en contanten. Deze overeenkomst stelt Core Scientific in staat om efficiënt te worden. <a href="https://www.gate.io/blog_detail/3250/-upcoming-bitcoin-halving-survival-miners" target="_blank">voor het bitcoin halveringsevenement van 2024</a>. Hoge kosten voor elektriciteit en lage bitcoin prijs dragen bij aan financiële verliezen voor mijnbouwbedrijven.</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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>