Qml0Y29pbi1pbmtvbXN0ZW4gc3R1d2VuIEJsb2NrIEluYy4gbmFhciAkMiw2IG1pbGphcmQ6IG1hcmt0c2VudGltZW50

2024-08-14, 02:40

<p><img src="https://gimg2.gateimg.com/image/article/17236028241690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR599354"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Block Inc., de betalingsgigant geleid door Jack Dorsey, meldde een opmerkelijke stijging van 9% op jaarbasis in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> omzet voor het tweede kwartaal van 2024, bereikt $2,61 miljard.</p>
<p>In een recente aandeelhoudersbrief meldde Block dat de totale nettowinst voor het kwartaal uitkwam op $6,16 miljard, wat een stijging van 11% betekent ten opzichte van dezelfde periode in 2023.</p>
<p>Bij uitsluiting van de Bitcoin-inkomsten bedroeg de omzet van het bedrijf $3,54 miljard, wat een jaarlijkse groei van 13% weerspiegelt.</p>
<p>Block berekent de Bitcoin-inkomsten als de totale waarde van BTC die aan haar klanten is verkocht.</p>
<p>Cash App, het vlaggenschip van Block’s dienst, droeg $4,13 miljard bij aan de kwartaalomzet. Zonder Bitcoin-transacties bedroeg de omzet van Cash App $1,52 miljard. De app zag ook een aanzienlijke stijging in de brutowinst van Bitcoin, die met 52% steeg op jaarbasis tot $67 miljoen in Q2 2024.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Bitcoin Prijsvoorspellingen voor 2024-2030</a></p>
<h2 id="h2-Block20en20het20BTCsaga766607"><a name="Block en het BTC-saga" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Block en het BTC-saga</h2><p>De toename van de brutowinst van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> werd grotendeels toegeschreven aan een hoger gemiddelde <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">BTC-prijs</a>, die in 2024 met meer dan 45% is gestegen en op het moment van het rapport wordt verhandeld voor $64.777. Block meldde echter een verlies van $70 miljoen op zijn Bitcoin-activa, met ongeveer 8.211 BTC ter waarde van $515 miljoen op de balans per 30 juni 2024. Het bedrijf voegde ongeveer 173 BTC toe tijdens het kwartaal.</p>
<p>De totale brutowinst van Block groeide met 20% ten opzichte van het voorgaande jaar en bedroeg $2,23 miljard. De nettowinst toewijsbaar aan gewone aandeelhouders bedroeg $195 miljoen, bijna een verdubbeling ten opzichte van $102 miljoen in hetzelfde kwartaal vorig jaar.</p>
<p>Om zijn financiële positie te versterken, kondigde Block in mei aan dat het $2 miljard wil ophalen via senior niet-gedekte obligaties voor gekwalificeerde institutionele beleggers. Het bedrijf verklaarde dat het met de opbrengsten van deze schulduitgifte het tweede kwartaal van 2024 afsloot met $10,3 miljard aan beschikbare liquiditeit.</p>
<p>De fondsen uit de schulduitgifte zijn bestemd voor verschillende doeleinden, waaronder schuldaflossing, overnames, strategische transacties, kapitaaluitgaven, investeringen en werkkapitaal.</p>
<h2 id="h2-Dorseys20plannen20over20BTC575479"><a name="Dorsey’s plannen over BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dorsey’s plannen over BTC</h2><p>Block Inc., geleid door Jack Dorsey, heeft plannen uitgestippeld om zijn Bitcoin-voorraad aanzienlijk te vergroten tot 2024. Het bedrijf heeft een Bitcoin dollar-cost averaging (DCA) aankoopprogramma geïmplementeerd, waarbij 10% van de brutowinst van zijn Bitcoin-gerelateerde producten wordt gereserveerd om elke maand extra Bitcoin te verwerven. Deze strategische beslissing komt overeen met Block’s geloof in Bitcoin als een instrument voor economische autonomie, waardoor individuen kunnen deelnemen aan een wereldwijd financieel systeem en hun financiële toekomst onafhankelijk kunnen beheersen.</p>
<p>Dit initiatief, dat in april 2024 is gestart, zal het hele jaar doorlopen en ervoor zorgen dat Block atisch zijn Bitcoin-reserves verhoogt, ongeacht de marktomstandigheden. Deze aanpak weerspiegelt het langetermijnvertrouwen van Block in het potentieel van Bitcoin als een transformerend bezit.</p>
<p>Block’s toewijding aan Bitcoin wordt verder weerspiegeld in haar uitgebreide strategie voor het beheren van haar Bitcoin-bezittingen. Dit omvat gedetailleerde plannen voor aankoopuitvoering, opslagmechanica, en verzekerings- en boekhoudkundige overwegingen, waarbij wordt gewaarborgd dat de investering van het bedrijf in Bitcoin goed beschermd en strategisch beheerd wordt. Deze initiatief ondersteunt niet alleen de financiële doelen van Block, maar benadrukt ook haar langetermijnvertrouwen in het potentieel van Bitcoin.</p>
<h2 id="h2-Andere20bedrijven20met20BTCbezittingen923855"><a name="Andere bedrijven met BTC-bezittingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere bedrijven met BTC-bezittingen</h2><p>Verschillende opmerkelijke bedrijven kopen actief Bitcoin om als onderdeel van hun bedrijfsreserves te houden. Hier zijn enkele van de belangrijkste:</p>
<p>MicroStrategy: Vooroplopend, MicroStrategy heeft de grootste hoeveelheid Bitcoin in handen van alle beursgenoteerde bedrijven. Op dit moment bezitten ze ongeveer 158.400 BTC. Het bedrijf, onder leiding van Michael Saylor, is een sterke voorstander van Bitcoin, waarbij het wordt gezien als een strategisch bezit en voortdurend hun bezittingen vergroot door middel van verschillende kapitaalverhogende initiatieven.</p>
<p>Marathon Digital Holdings: Dit in de VS gevestigde cryptocurrency miningbedrijf heeft ongeveer 13.726 BTC in bezit. Marathon Digital breidt zijn miningactiviteiten en reserves uit, waardoor het een van de grootste Bitcoin-houders is onder miningbedrijven.</p>
<p>Tesla: Het bedrijf voor elektrische voertuigen en schone energie, geleid door Elon Musk, bezit ongeveer 10.500 BTC. Hoewel Tesla een fluctuerende relatie met Bitcoin heeft gehad, blijft het een van de belangrijke zakelijke houders van de cryptocurrency.</p>
<p>Hut 8 Mining Corp: Dit Canadese Bitcoin mining bedrijf heeft ongeveer 9.255 BTC. Hut 8 heeft zich gericht op het vergroten van zijn Bitcoin bezittingen door middel van zijn mining activiteiten en strategische overnames.</p>
<p>Riot Platforms, Inc.: Een andere belangrijke speler in de Bitcoin-mijnbouwindustrie, Riot Platforms (voorheen Riot Blockchain), bezit ongeveer 9.084 BTC. Het bedrijf heeft zwaar geïnvesteerd in het uitbreiden van zijn mijnbouwcapaciteit in de VS.</p>
<p>Galaxy Digital Holdings: Deze op cryptocurrency gerichte handelsbank bezit ongeveer 8.100 BTC. Opgericht door Michael Novogratz, is Galaxy Digital een belangrijke speler geweest in de cryptocurrency-investeringsruimte.</p>
<p>Deze bedrijven beschouwen Bitcoin als een strategisch bezit, dat bijdraagt aan hun financiële reserves en profiteert van het potentieel voor waardestijging op lange termijn.</p>
<h2 id="h2-Hoe20benvloedt20dit20de20BTCprijs190362"><a name="Hoe beïnvloedt dit de BTC-prijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe beïnvloedt dit de BTC-prijs</h2><p>De aanzienlijke accumulatie van Bitcoin door grote bedrijven kan verschillende gevolgen hebben <a href="https://www.gate.io/blog_detail/26" target="_blank">op de prijs van Bitcoin</a>:</p>
<p>1-Verhoogde vraag: wanneer bedrijven zoals MicroStrategy, Tesla en Block Inc. grote hoeveelheden Bitcoin kopen, neemt de vraag naar de cryptocurrency aanzienlijk toe. Aangezien Bitcoin een beperkte voorraad heeft van 21 miljoen munten, zorgt een hogere vraag doorgaans voor een stijging van de prijs. Hoe meer Bitcoin deze bedrijven kopen, hoe meer schaarste er op de markt ontstaat, wat kan leiden tot hogere prijzen.</p>
<p>2-Marktsentiment: Grote aankopen door bekende bedrijven kunnen een positieve invloed hebben op het marktsentiment. Beleggers beschouwen deze acties vaak als een goedkeuring van de waarde en legitimiteit van Bitcoin. Dit kan meer institutionele en particuliere beleggers aantrekken, wat de vraag en de prijs verder kan stimuleren. Wanneer een bedrijf zoals MicroStrategy <a href="https://www.gate.io/blog/1595/what-is-behind-microstrategy-all-in-btc" target="_blank">doet een investering met veel impact</a>, het kan vertrouwen in de toekomst van Bitcoin signaleren en anderen aanmoedigen hetzelfde te doen​.</p>
<ol>
<li><p>Verminderde Volatiliteit: Na verloop van tijd, naarmate meer instellingen Bitcoin aanhouden, kan de markt minder volatiel worden. Institutionele beleggers hebben de neiging om activa langer aan te houden dan particuliere beleggers, waardoor de frequentie en impact van grote verkopen afnemen. Deze toegenomen stabiliteit kan Bitcoin aantrekkelijker maken voor andere potentiële beleggers, mogelijk leidend tot verdere prijsstijgingen.</p>
</li><li><p>Marktvloeibaarheid: Hoewel grootschalige overnames tijdelijk de liquiditeit kunnen verminderen (waardoor er minder Bitcoins beschikbaar zijn voor handel), kunnen ze ook de algehele marktvloeibaarheid verbeteren, omdat instellingen vaak op een meer gestructureerde en voorspelbare manier handelen. Dit kan de markt dieper maken en veerkrachtiger tegen schokken, waardoor de prijzen op de lange termijn mogelijk stabiliseren.</p>
</li><li><p>Netwerkeffecten: Naarmate meer bedrijven Bitcoin integreren in hun balansen en activiteiten, komt het netwerkeffect in werking. Meer gebruik en acceptatie kunnen leiden tot bredere adoptie, waardoor de waardepropositie van Bitcoin als wereldwijde digitale valuta wordt versterkt. Deze wijdverbreide adoptie kan de prijs omhoog drijven vanwege het toegenomen gebruik op verschillende platforms en diensten.</p>
</li><li><p>Regelgevende invloed: De betrokkenheid van grote bedrijven bij Bitcoin kan regelgevende aandacht trekken, wat mogelijk kan leiden tot duidelijkere regelgeving. Hoewel dit aanvankelijk onzekerheid en volatiliteit kan veroorzaken, kunnen duidelijke regelgevende kaders legitimiteit en veiligheid bieden voor institutionele beleggers, waardoor verdere investeringen worden aangemoedigd en de prijs van Bitcoin mogelijk stijgt.</p>
</li></ol>
<p>Over het algemeen is de activiteit van grootschalige bedrijfsovernames over het algemeen bullish voor de prijs van Bitcoin, omdat het vertrouwen in de toekomstige waarde en bruikbaarheid ervan benadrukt, meer investeerders aantrekt en kan leiden tot verhoogde adoptie en stabiliteit in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a>.</p>
<h2 id="h2-Veelgestelde20vragen73060"><a name="Veelgestelde vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen</h2><h3 id="h3-Wat20doet20Jack20Dorsey20met20Bitcoin311496"><a name="Wat doet Jack Dorsey met Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat doet Jack Dorsey met Bitcoin?</h3><p>Dorsey heeft de neiging om stil te blijven.</p>
<p>Zelfs als hij spreekt, spreekt hij zacht, maar hij heeft veel geïnvesteerd in Bitcoin. Onlangs heeft hij $21 miljoen toegezegd voor de ontwikkeling van open source. En hij heeft geïnvesteerd in Bitcoin-startups, zoals Lightning Labs.</p>
<h3 id="h3-Hoeveel20verdient20Block20aan20Bitcoin947570"><a name="Hoeveel verdient Block aan Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel verdient Block aan Bitcoin?</h3><p>Block, maker van de Cash App, heeft een stijging van de omzet uit de verkoop van bitcoin van $660,8 miljoen geregistreerd in het derde kwartaal van 2023</p>
<h3 id="h3-Hoeveel20bitcoin20bezit20Block208714"><a name="Hoeveel bitcoin bezit Block?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel bitcoin bezit Block?</h3><p>Block, Inc. bezit 8.027 BTC</p>
<h3 id="h3-Koopt20Block20Bitcoin64866"><a name="Koopt Block Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Koopt Block Bitcoin?</h3><p>Block heeft de intentie om <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop bitcoin</a> maandelijks, te beginnen in april 2024, met behulp van Time-Weighted Average Price (TWAP) orders. Om slippage tot een minimum te beperken, zei het bedrijf dat het dat zal doen <a href="/crypto/buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop BTC</a>“over een tijdsbestek van twee uur waarin historisch gezien de grootste liquiditeit aanwezig is.”</p>
<div class="blog-details-info"><br><div>Auteur: <em>Andrei</em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<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 actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>