Qml0Y29pbiBTdXBwbHkgU2hvY2s6IE9udGh1bGxpbmcgdmFuIDUgVGhlb3JpZcOrbg==

2024-03-06, 06:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""></p>
<h2 id="h2-TL20DR992106"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het aanbod zal afnemen na het halveringsevenement dat wordt verwacht tussen 19 en 21 april.</p>
<p>BTC ETF’s hebben geholpen om de instroom in de bitcoinmarkt te verhogen.</p>
<p>De cryptomarkt verwacht dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> na het halveringsevenement binnen een bepaald bereik zal handelen voordat een mogelijke bull run begint.</p>
<h2 id="h2-Introductie940836"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De stijging <a href="https://www.gate.io/blog_detail/3434/btc-etf-approval-catalysts" target="_blank">in trek voor spot bitcoin ETF’s</a> hebben de interesse gewekt van veel investeerders te midden van de verwachtingen van de volgende bull run. Deze stijging in vraag <a href="https://www.gate.io/learn/articles/what-is-bitcoin-halving-and-why-is-it-important/175" target="_blank">en het naderende halveringsevenement</a> zullen waarschijnlijk een sterke aanbodschok veroorzaken die de hele cryptomarkt kan transformeren. Deze ontwikkelingen, waaronder de lancering van ordinaalinies, zullen naar verwachting de prijsontwikkeling van bitcoin in de komende 2 tot 3 jaar beïnvloeden.</p>
<p>Deze analyse richt zich op de 5 theorieën die de beperkte bitcoinvoorziening verklaren. We zullen ook kijken naar de mogelijke impact van de BTC-voorraadschok op de prijs en andere marktdynamiek.</p>
<h2 id="h2-De20groei20van20de20Spot20Bitcoin20ETF20voedt20de20verwachting20van20een20aanzienlijke20aanbodschok20te20midden20van20het20komende20Halvingevenement20in202024515061"><a name="De groei van de Spot Bitcoin ETF voedt de verwachting van een aanzienlijke aanbodschok te midden van het komende Halving-evenement in 2024." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De groei van de Spot Bitcoin ETF voedt de verwachting van een aanzienlijke aanbodschok te midden van het komende Halving-evenement in 2024.</h2><p>De prijs van bitcoin bereikte in januari $50.000, enkele dagen nadat de Verenigde Staten 11 spot bitcoin ETF’s hebben goedgekeurd. Nu verwacht de bitcoinmarkt dat de prijs zal stijgen zoals we <a href="https://www.gate.io/explore/bitcoin-halving-countdown" target="_blank">beweeg richting het halveringsgebeurtenis van 2024 dat plaatsvindt in april</a>.</p>
<p>De verwachte verlaging van het aanbod van bitcoin en de voortdurende verwerving van de munt door de BTC ETF-uitgevers zullen waarschijnlijk een sterke aanbodschok veroorzaken. Laten we eens kijken naar 5 theorieën die <a href="https://www.gate.io/blog_detail/1866/btc-halved-for-the-fourth-time-how-does-it-affect-the-supply-of-btc" target="_blank">leg de dreigende bitcoin aanbod schok uit</a>.</p>
<h2 id="h2-Theorie20120Bitcoin20ETF20instromen20stimuleert20de20vraag745018"><a name="Theorie 1: Bitcoin ETF instromen stimuleert de vraag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Theorie 1: Bitcoin ETF instromen stimuleert de vraag</h2><p>De eerste theorie komt van <a href="https://twitter.com/marcvanderchijs/status/1757945222007525598" rel="nofollow noopener noreferrer" target="_blank">Marc van der Chijs</a>, een Nederlandse ondernemer en investeerder. Van der Chijs stelt dat er een correlatie is tussen Bitcoin ETF instromen en de BTC-prijs. Door zijn waarneming concludeerde hij dat de vraag naar bitcoin ETF’s heeft geleid tot een stijging van 2% in de prijs sinds hun lancering.</p>
<p>Hij concludeerde ook dat de inefficiëntie van de bitcoinmarkt een grote invloed heeft op de prijs van de cryptocurrency. De inefficiëntie was het gevolg van de verwachting van de bitcoinmarkt van een prijsstijging als gevolg van de goedkeuring van de Verenigde Staten BTC ETF die plaatsvond op 10 januari.</p>
<p>Als de vraag naar bitcoin-producten zoals spot ETF’s groter is dan het aanbod van nieuw gemunte bitcoin, kan de prijs stijgen. Het feit dat veel bitcoin-houders het verkopen van hun BTC uitstellen in afwachting van verdere prijsstijgingen, heeft een tekort op de markt gecreëerd. Deze onbalans tussen vraag en aanbod van bitcoin zal naar verwachting toenemen na de bitcoin-halvering, wat de prijs kan opdrijven.</p>
<p>Plaatsen op zijn X-profiel, <a href="https://twitter.com/marcvanderchijs/status/1757945222007525598" rel="nofollow noopener noreferrer" target="_blank">Marc van der Chijs zei</a> Ik denk dat we hier op onbekend terrein zijn, maar ik geloof dat een gemiddelde stijging van $1000 per handelsdag in de komende weken zeer waarschijnlijk is.</p>
<p>Hij vervolgde: “Na de bovengenoemde 2 evenementen zou dit zelfs aanzienlijk hoger kunnen zijn. Dit betekent dat tenzij er een zwarte zwaan gebeurtenis plaatsvindt, we een nieuwe all-time high (&gt;$69K) zullen zien vóór de halvering en we mogelijk al binnen de komende 2-3 maanden $100K kunnen bereiken.”</p>
<h2 id="h2-Theorie20220Onderschatte20mondiale20kapitaalstromen355200"><a name="Theorie 2: Onderschatte mondiale kapitaalstromen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Theorie 2: Onderschatte mondiale kapitaalstromen</h2><p>Een andere theoreticus, Andrew Kang, mede-oprichter van Mechanism Capital, heeft zijn perspectief gegeven over de langetermijndemand en prijsbewegingen van bitcoin. Zijn visie is dat op de lange termijn het totale inkomen en het mondiale vermogen van invloed zullen zijn op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a>.</p>
<p>Kang gebruikte het gemiddelde inkomen van Amerikaanse huishoudens om de totale vraag naar bitcoin te voorspellen. Hij heeft geschat dat er in de toekomst ongeveer $52 biljoen in cryptocurrencies zal worden geïnvesteerd. Met die verwachte geldinstroom in de cryptomarkt zei Kang dat ongeveer $52 miljard per jaar, wat neerkomt op $150 miljoen per dag, geïnvesteerd kan worden. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a> in bitcoin omdat het de nummer één cryptocurrency is.</p>
<p>Desondanks is dit cijfer zeer conservatief, omdat hij heeft voorspeld dat slechts 1% van de $52 biljoen in bitcoin zal stromen. Deze schatting houdt dus geen rekening met bitcoin-enthousiastelingen en institutionele beleggers die mogelijk <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a> in grote hoeveelheden. De volgende grafiek toont de inkomensverdeling in de Verenigde Staten, die Kang mogelijk heeft gebruikt bij zijn berekeningen.<br><img src="https://gimg2.gateimg.com/image/article/1709707785img_v3_028n_2cf2c85b-6df0-40e6-934b-80932433a4ix.jpg" alt=""><br>Percentageverdeling van huishoudinkomen - Statista</p>
<p>Kang, net als andere analisten, zei dat instroom in bitcoin ETF’s kan leiden tot een stijging in de vraag naar BTC. De dagelijkse instroom in de BTC ETF-markt in de Verenigde Staten is al hoger dan de oorspronkelijke schattingen.</p>
<p>Volgens <a href="https://cryptonews.net/news/bitcoin/28566648/" rel="nofollow noopener noreferrer" target="_blank">een Cryptonieuws publicatie</a>, Kang zei: ‘Ik geloof nog steeds dat deze ETF-lancering niet te vergelijken is met eerdere gebeurtenissen zoals CME futures, Coinbase IPO, enz. En we besteden geen tijd onder de $40.000. [We zullen zien] $50.000 tot $60.000 in februari, en een [all-time high] in maart.’</p>
<p>Lees ook: <a href="https://www.gate.io/tw/blog_detail/26" target="_blank">Bitcoin prijsvoorspellingen voor 2025</a></p>
<h2 id="h2-Theorie20320De20instroom20van20lange20termijninstituties92970"><a name="Theorie 3: De instroom van lange termijn-instituties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Theorie 3: De instroom van lange termijn-instituties</h2><p>Ric Edelman, de oprichter van de Digital Assets Council of Financial Professionals, is de man achter deze theorie. Hij gelooft dat er veel geld naar de bitcoinmarkt zal stromen als gevolg van institutionele en individuele adviseursinvesteringen, vooral via ETF’s.</p>
<p>De reden hiervoor is dat onafhankelijke financieel adviseurs, die in totaal ongeveer $8 biljoen aan activa beheren, geïnteresseerd zijn om te investeren in bitcoinproducten zoals spot-ETF’s. Dit geeft aan dat digitale activa breder worden geaccepteerd als potentiële lucratieve beleggingsinstrumenten.</p>
<p>Edelman schatte dat er mogelijk een instroom van meer dan $150 miljard kan zijn van onafhankelijke adviseurs naar de digitale activamarkt. Een dergelijk bedrag zal waarschijnlijk de waarde van bitcoin doen stijgen.</p>
<p><a href="https://beincrypto.com/theories-explain-bitcoin-supply-shock/" rel="nofollow noopener noreferrer" target="_blank">Beincrypto heeft Edelman geciteerd als zeggende</a>“Ik verwacht dat tegen de tijd dat we eind 2025 komen, we hebben het over 2 jaar, we een totale instroom van meer dan $ 150 miljard zullen zien. We zitten nu pas op 5 miljard dollar.”</p>
<h2 id="h2-Theorie20420Bitcoin20Halving202024189454"><a name="Theorie 4: Bitcoin Halving 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Theorie 4: <a href="/explore/bitcoin-halving-countdown" target="_blank" class="blog_inner_link">Bitcoin Halving</a> 2024</h2><p>Het bitcoin-halveringsevenement, geprogrammeerd in zijn protocol, vermindert de beloning voor bitcoin miners met de helft na ongeveer elke 4 jaar. De volgende bitcoin-halvering, verwacht <a href="https://www.gate.io/blog_detail/2330/bitcoin-halving-preview-in-2024" target="_blank">tussen 19 en 21 april</a>, zal de beloningen voor de mijnwerkers verlagen van 6.25 naar 3.125, waardoor de dagelijkse uitgifte zal afnemen van 900 BTC naar 450 BTC.</p>
<p>Dit zal zeker het aanbod van bitcoin verlagen. Als gevolg hiervan zal het waarschijnlijk de prijs van bitcoin binnen 6 tot 12 maanden na het halveringsevenement omhoog duwen. Historisch gezien handelde bitcoin na elke halvering een paar maanden in een bereik voordat het aan een bull run begon.</p>
<p>Hierover commentaar gevend, <a href="https://twitter.com/JohnNosta/status/1723366296773861750" rel="nofollow noopener noreferrer" target="_blank">John Nosta, een crypto-analist, zei</a>, “De anticipatie van verminderde aanbod kan vraag en speculatieve investeringen aansturen in aanloop naar een halvering.”</p>
<p>Hij voegde eraan toe: “Het halveren vertraagt geleidelijk de snelheid van nieuwe muntcreatie, waardoor schaarste wordt gegarandeerd en de waarde in de loop van de tijd mogelijk toeneemt. Historisch gezien heeft Bitcoin aanzienlijke prijsstijgingen meegemaakt in de maanden na een halvering, hoewel dit wordt beïnvloed door vele factoren en niet alleen het halveringsevenement.”</p>
<h2 id="h2-Theorie20520Bitcoinbelegger20accumulatie701671"><a name="Theorie 5: Bitcoin-belegger accumulatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Theorie 5: Bitcoin-belegger accumulatie</h2><p>Vanwege de aankomende bitcoin-halvering verzamelen veel beleggers BTC in afwachting van een prijsstijging van bitcoin na dat evenement. Inderdaad, veel geïnformeerde individuele en institutionele beleggers kopen BTC en houden het vast.</p>
<p>Als voorbeeld, <a href="https://cryptoquant.com/community/dashboard/657c175d21681e353193aaad" rel="nofollow noopener noreferrer" target="_blank">Ki Young Ju, CEO van CryptoQuant, meldde</a> Op 19 februari hebben walvisadressen van Bitcoin een nettostroom van 25.300 BTC verzameld, wat wijst op de kooplust van investeerders naarmate we ons naar het halveringsevenement bewegen.</p>
<h2 id="h2-Conclusie179172"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Samenvattend hebben we gekeken naar 5 belangrijkste theorieën die de bestaande en verwachte bitcoin aanbodschok verklaren. De aanbodschok en een stijgende vraag naar bitcoin dwingen de prijs omhoog. Toch geloven veel analisten dat de prijs van bitcoin waarschijnlijk zal stijgen na het halveringsevenement van bitcoin.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>