TWFyYXRob24gRGlnaXRhbCBicmVpZHQgemlqbiBtaWpuYm91d2hvcml6b24gdWl0IG1ldCAkMTZNIEthc3BhIGVuIHN0cmVlZnQgbmFhciBkaXZlcnNpZmljYXRpZSB2b29yYmlqIEJpdGNvaW4u

2024-07-10, 06:25

<p><img src="https://gimg2.gateimg.com/image/article/1720592472sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR666411"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Naast <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Marathon Digital mijnt nu Kaspa.<br>In het afgelopen jaar presteerde KSA beter dan bitcoin.</p>
<p>Marathon heeft 1% van zijn rekenkracht gereserveerd voor het delven van KAS.</p>
<h2 id="h2-Introductie697559"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De daling van de bitcoin-mijnbeloningen en de mogelijkheid van een depressie <a href="https://www.gate.io/learn/articles/crypto-pulse-13/3394" target="_blank">De BTC-markt heeft invloed gehad op mijnwerkers</a> om hun investeringen te diversifiëren. Sommigen schakelen hun rekenkracht over naar de kunstmatige intelligentiesector, terwijl anderen diversifiëren naar het delven van andere cryptocurrencies. Marathon Digital is een van de miners die heeft geïnvesteerd in het delven van Kaspa. Vandaag richten we ons op de strategische zet van Marathon Digital om Kaspa te delven. We zullen ook de rendementen vergelijken die worden gegenereerd door het delven van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en het delven van Kaspa.</p>
<h2 id="h2-De20strategische20zet20van20Marathon20Digital20in20Kaspamining761333"><a name="De strategische zet van Marathon Digital in Kaspa-mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De strategische zet van Marathon Digital in Kaspa-mining</h2><p>Marathon Digital, een van de toonaangevende cryptominingbedrijven, heeft zijn cryptocurrency-strategie uitgebreid door zich te diversifiëren in het minen van Kaspa, een inheemse cryptocurrency van Kaspa, een open-source, schaalbaar en gedecentraliseerd Layer-1-protocol dat het proof-of-work-consensusmechanisme gebruikt. Het feit dat het minen van zowel Bitcoin als Kaspa dezelfde mijnbouwtechnologie gebruikt, maakt de mijnbouwdiversificatie van Marathon gemakkelijk en winstgevend, omdat het al de benodigde expertise en capaciteit heeft.</p>
<p>Marathon heeft inmiddels $16 miljoen aan Kaspa toegevoegd aan zijn cryptoportfolio. De voornaamste reden voor deze stap is om de schaalbaarheidsuitdagingen van bitcoin aan te pakken en tegelijkertijd te profiteren van de hogere winstmarges van Kaspa mining. In lijn hiermee, via een persbericht, <a href="https://ir.mara.com/news-events/press-releases/detail/1360/marathon-digital-holdings-announces-kaspa-mining-operations" rel="nofollow noopener noreferrer" target="_blank">Adam Swick, Chief Growth Officer van Marathon, zei</a>“Door Kaspa te minen, kunnen we een inkomstenstroom creëren die gediversifieerd is van Bitcoin.”</p>
<p>Hij breidde het punt uit door te zeggen: “Vanwege onze bestaande infrastructuur, onze unieke relaties met hardwarefabrikanten, onze sterke balans en de expertise van ons team, was Marathon uniek gepositioneerd om Kaspa te mijnen en te profiteren van de hogere marges die er zijn voor degenen die vandaag Kaspa ASIC’s kunnen implementeren. We kijken ernaar uit om innovatie in proof-of-work ecoen te blijven ondersteunen.”</p>
<p>Ondanks deze uitbreiding van de mijnbouw blijft Marathon Digital zich richten op Bitcoin vanwege de mogelijke levensvatbaarheid op lange termijn. Post op <a href="https://x.com/MarathonDH/status/1806057646514147337?lang=en" rel="nofollow noopener noreferrer" target="_blank">X Marathon uitgelegd</a>: “Hoewel we sterk geloven in de levensvatbaarheid van Bitcoin op de lange termijn en verwachten dat transactiekosten de inkomsten uit mining zullen ondersteunen, streven we naar nieuwe wegen voor groei. Kaspa-mijnbouw is slechts een van de vele inspanningen achter deze prioriteit, vergelijkbaar met onze initiatieven op het gebied van energieoogst en technologieproducten. Deze uitbreiding creëert een inkomstenstroom die gediversifieerd is ten opzichte van Bitcoin en tegelijkertijd proof-of-work (PoW) innovatie ondersteunt.”</p>
<p>De crypto-mijnbouwgigant gaf verschillende redenen aan voor zijn bitcoin-diversificatie en toetreding tot de Kaspa-mijnbouwsector. Ten eerste is de Kaspa-technologie zeer geavanceerd, wat veel mensen kan verleiden om te investeren in KAS. Bijvoorbeeld, GHOSTDAG, het consensusmechanisme van Kaspa, heeft een zeer hoge doorvoer aangezien het 1 blok per seconde verwerkt. Dit komt doordat de gerichte acyclische graaf (DAG) structuur van Kaspa de verwerking van meerdere blokken tegelijk ondersteunt.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Bitcoin Prijsvoorspelling &amp; Voorspelling voor 2024, 2025, 2030</a></p>
<p>Kaspa heeft al een circulerende voorraad van 24 miljard KAS en een blokbeloning van 103,83 KAS. Het staat nu al in de top 25 van cryptocurrencies op basis van marktkapitalisatie, wat hoop geeft dat het in de toekomst nog meer aandacht zal krijgen. Volgens de strategie van Marathon Digital zal de Kaspa-mijnbouw echter beperkt worden tot slechts 1% van de operationele capaciteit, wat ‘ongeveer 16% van de wereldwijde hash-snelheid van Kaspa vandaag’ vertegenwoordigt.</p>
<p>Op 31 mei hield Marathon 17.857 bitcoin op zijn balans. Aan de andere kant heeft het sinds september 2023 9.761 BTC gedolven. Op dezelfde manier heeft het bedrijf in dezelfde periode 93 miljoen KAS-tokens gedolven. Om zijn cryptominingactiviteiten verder te stimuleren, heeft Marathon 60 petahashes aan KS3, KS5 en KS5 Pro ASIC’s verworven. Bijna de helft van deze mining-rigs is echter nog niet geïnstalleerd.</p>
<h2 id="h2-Crypto20Mining20Analyse20Vergelijking20tussen20Bitcoin20en20Kaspa20Mining945458"><a name="Crypto Mining Analyse: Vergelijking tussen Bitcoin en Kaspa Mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Mining Analyse: Vergelijking tussen Bitcoin en Kaspa Mining</h2><p>Een korte vergelijking van bitcoin met KAS kan ons helpen om te waarderen waarom Marathon zich heeft gediversifieerd in het delven van Kaspa. Het huidige vooruitzicht voor cryptocurrency laat zien dat KAS een hoger rendement heeft dan bitcoin. In een persbericht heeft Marathon gereageerd op het rendement van KAS. <a href="https://x.com/MarathonDH/status/1806057646514147337?lang=en" rel="nofollow noopener noreferrer" target="_blank">Het verklaarde</a> De winstmarge van Marathon op haar Kaspa-activiteiten is aantrekkelijk geweest vanwege de inzet van de meest geavanceerde technologische hardware, waarbij in bepaalde glen marges tot 95% worden nagestreefd.</p>
<p>Bovendien tonen de koersbewegingen van de twee cryptocurrencies aan dat de prestaties van KAS beter waren dan die van bitcoin. Zo steeg de prijs van KAS sinds september 2023 met 420% in vergelijking met de 135% van BTC. Daarom heeft de Kaspa-tokenstijging gedurende die periode het grote potentieel laten zien dat het heeft.</p>
<p>De huidige prestaties van de cryptocurrency-marktprijs geven ook aan dat KAS beter presteert dan BTC. Volgens <a href="https://www.coingecko.com/en/coins/kaspa" rel="nofollow noopener noreferrer" target="_blank">CoinGecko KAS verloor slechts 2,4%</a> in de afgelopen 30 dagen, maar in het afgelopen jaar met 692,5% gestegen. Daarentegen <a href="https://www.coingecko.com/en/coins/bitcoin" rel="nofollow noopener noreferrer" target="_blank">Bitcoin verloor met 19,2%.</a> in de afgelopen 30 dagen en slechts met 90,9% gestegen in het afgelopen jaar.</p>
<p>Het is ook belangrijk op te merken dat de mijnbouwrigs voor KAS winstgevender zijn dan die van Bitcoin vanwege hun efficiëntieniveaus. Dit betreft <a href="https://x.com/MarathonDH/status/1806057646514147337?lang=en" rel="nofollow noopener noreferrer" target="_blank">Marathon zei</a>, “Op dit moment kan een Kaspa-mining KS5 Pro naar schatting $79 per dag aan winst opleveren, in vergelijking met $11 voor een BTC-mining S21. Met dit winstniveau verwachten we een snellere terugverdientijd van de Kaspa ASIC’s. Tot op heden heeft Marathon ongeveer 93 miljoen KAS (ongeveer $15 miljoen) gegenereerd.”</p>
<h2 id="h2-Kaspa20Mining20in20Marathons20Algemene20Strategie615736"><a name="Kaspa Mining in Marathon’s Algemene Strategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kaspa Mining in Marathon’s Algemene Strategie</h2><p>Zoals hierboven aangegeven, zal Marathon slechts een klein percentage van zijn rekenkracht toewijzen aan KAS en de rest behouden. <a href="https://www.gate.io/learn/articles/what-is-btc-mining/287" target="_blank">rust voor bitcoin mining</a>. Het mijnbouwbedrijf heeft niet het doel om zijn toewijzing van rekenkracht aan KAS te vergroten, tenzij het besluit zijn huidige cryptocurrency-strategie te wijzigen. In zijn blog verklaarde Marathon: “We hebben op dit moment geen plannen om onze Kaspa-activiteiten uit te breiden buiten de initiële bestelling. We zullen echter de markt blijven volgen voor groeikansen, waaronder andere PoW-blockchains of digitale activa, aangezien Marathon blijft innoveren en investeren in het beveiligen van netwerken.”</p>
<h2 id="h2-Hoe20KSA20te20kopen20op20Gateio875732"><a name="Hoe KSA te kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe KSA te kopen op Gate.io</h2><p>Naar <a href="https://www.gate.io/how-to-buy/kaspa-kas" target="_blank">koop KAS op Gate.io</a> Je moet een account aanmaken en verifiëren op de beurs. Als je al een geverifieerd account hebt, log in en selecteer de betaalmethode die je wilt gebruiken. Je kunt een credit-/bankpas, overschrijving of P2P-handel gebruiken. Als je enkele belangrijke cryptocurrencies zoals bitcoin, ETH en USDT hebt, kun je eenvoudig een daarvan naar KSA converteren.</p>
<h2 id="h2-Conclusie826073"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Marathon Digital heeft zijn cryptocurrency mining uitgebreid naar Kaspa (KSA). Op dit moment heeft KAS een hoger rendement dan Bitcoin. Het bedrijf zal echter slechts 1% van zijn rekenkracht toewijzen aan Kaspa mining. Ondertussen heeft KSA, dat in het afgelopen jaar met meer dan 692% is gestegen, BTC overtroffen, waarvan de waarde slechts met 90,9% is gestegen.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel te herposten, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>