RGFnZWxpamtzIG5pZXV3cyB8IDkgQml0Y29pbiBFVEYncyBtZXQgZWVuIHZlcm1vZ2Vuc2JlaGVlcnNjaGFhbCB2YW4gJDRCLCBCbGFja1JvY2sgc3RvcHQgbWV0IGhldCBsYW5jZXJlbiB2YW4gWFJQIFNwb3QgRVRGJ3MsIFNvbGFuYSBTdGFibGVjb2luIFRyYW5zZmVyIFZvbHVtZSBSZWNvcmRzIG1hYW5kZWxpamtzZSBob29ndGVwdW5

2024-01-22, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/17058967091_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BlackRock20Stopte20met20Lancering202020XRP2020Spot20ETFs202020Solana2020Stablecoin20overdracht20volume20bereikt20maandelijks20hoogtepunt64656"><a name="Crypto Dagelijkse Samenvatting: BlackRock Stopte met Lancering   XRP  Spot ETF’s,   Solana  Stablecoin overdracht volume bereikt maandelijks hoogtepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BlackRock Stopte met Lancering <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Spot ETF’s, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Stablecoin overdracht volume bereikt maandelijks hoogtepunt</h2><p>Allereerst, laten we ons richten op de situatie van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETFs.</p>
<p>Na zes dagen handel hebben negen goedgekeurde spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s momenteel in totaal ongeveer 95000 Bitcoins en beheren ze activa (AUM) van bijna $4 miljard. Volgens gegevens die zijn bekendgemaakt door Eric Balchunas, een senior ETF-analist bij Bloomberg, heeft de instroom van geld van de negen recent gelanceerde ETF’s de uitstroom van grayscale GBTC overtroffen. De activa beheerd door GBTC daalden met $2,8 miljard binnen zes dagen.</p>
<p>Van deze 9 ETF’s presteerden Fidelity’s FBTC en BlackRock’s iShares (IBIT) goed, met instromen van meer dan $1,2 miljard in zes handelsdagen. Hoewel de instroom van Fidelity ETF’s iets hoger is, beheert BlackRock momenteel iets meer activa van $1,4 miljard, in vergelijking met bijna $1,3 miljard van Fidelity. Jingshun ETF (BTCO) staat op de derde plaats en handhaaft een stabiele groei.</p>
<p>Volgens mediaberichten heeft BlackRock besloten te stoppen met het lanceren van spot <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETF’s, een beslissing genomen in het licht van aanhoudende regelgevingsonzekerheid en onduidelijke wettelijke status van XRP. BlackRock heeft eerder interesse getoond in het digitale valutaveld, waarbij CEO Larry Fink suggereerde dat het bedrijf zal samenwerken met XRP. Een uitspraak in juli bracht echter verwarring over de juridische status van XRP, wat leidde tot de beslissing van het bedrijf om zich terug te trekken uit het lanceren van spot <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> ETF’s.</p>
<p>Volgens CoinGecko-gegevens bedraagt de huidige marktwaarde van cryptocurrencies $1,723 biljoen, met een dagelijkse stijging van 0,7%. Het handelsvolume van de afgelopen 24 uur bedraagt $34,7447 miljard, waarbij Bitcoin momenteel goed is voor 47,4% van de marktwaarde en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> goed voor 17,2%.</p>
<p>Andere gegevenswijzigingen, volgens Artemis-gegevens, zijn dat het bedrag van de Stablecoin-overdracht op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> overschreed in januari $300 miljard, wat hoger is dan de $297 miljard in december vorig jaar. Bovendien bedraagt het totale bedrag aan Stablecoin-overdrachten tot nu toe in januari $303 miljard, een stijging van 2520% ten opzichte van het bedrag van $11,56 miljard aan Stablecoin-overdrachten in januari 2023.</p>
<p>Solana’s marktaandeel in stablecoins is momenteel bijna 32%, een aanzienlijke toename van 1,2% een jaar geleden. De activiteit in stablecoins op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> is sinds oktober aan het herstellen en is gestaag met 650% toegenomen.</p>
<p>Volgens de gegevens van Token Unlocks hebben in totaal vier projecten deze week een eenmalige grote ontgrendeling ervaren, waaronder:</p>
<p>Om 15:00 uur (UTC) op 23 januari, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> zal 575000 DYDX’s ontgrendelen (ongeveer $1,62 miljoen), goed voor 0,18% van de circulerende voorraad;</p>
<p>Om 0:00 (UTC) uur op 25 januari zal Acala 4,66 miljoen ACAs (ongeveer $438,000) vrijgeven, wat overeenkomt met 0,53% van de circulerende voorraad;</p>
<p>Om 14:00 (UTC) uur op 27 januari zal Yield Guild Games 16,69 miljoen YGG’s (ongeveer $8,75 miljoen) ontgrendelen, goed voor 5,94% van de circulerende voorraad;</p>
<p>Om 0:00 (UTC) op 28 januari zal Singularity NET 9.11 miljoen AGIXs (ongeveer $2.54 miljoen) ontgrendelen, wat overeenkomt met 0.73% van de circulerende voorraad.</p>
<h2 id="h2-Macro20De20Federal20Reserve20onderdrukt20renteverlagingen20en20richt20zich20op20de20BBP20en20PCEgegevens20van20de20VS20van20deze20week697241"><a name="Macro: De Federal Reserve onderdrukt renteverlagingen en richt zich op de BBP- en PCE-gegevens van de VS van deze week" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve onderdrukt renteverlagingen en richt zich op de BBP- en PCE-gegevens van de VS van deze week</h2><p>De sterke economische gegevens die vorige week werden vrijgegeven, waaronder de detailhandelsverkopen, suggereren dat de Federal Reserve mogelijk niet zo agressief de rente zal verlagen als verwacht door de markt. Tegelijkertijd hebben functionarissen van de Federal Reserve sterk gereageerd op speculatie over renteverlagingen. Bostic drong er bij besluitvormers op aan om voorzichtig te handelen bij het versoepelen van het beleid, terwijl Federal Reserve-directeur Waller lijkt te twijfelen aan de huidige vraag naar sterke renteverlagingen.</p>
<p>Daarom hebben handelaren die oorspronkelijk verwachtten dat de rentetarieven zes keer zouden worden verlaagd in 2024, hun verwachtingen nu verlaagd tot vijf, en hun zekerheid over of deze renteverlagingen in maart zullen beginnen, is aanzienlijk afgenomen.</p>
<p>Echter, na te hebben geaarzeld aan het begin van het jaar, steeg de S&amp;P 500 index voor de tweede opeenvolgende week, waardoor de index naar een nieuw hoogtepunt steeg, voornamelijk gedreven door technologieaandelen. De Nasdaq 100 index vestigde een record en steeg bijna 3% deze week. Tegelijkertijd hebben de Amerikaanse staatsobligaties, die het vorige jaar eindigden met een historische stijging, verliezen geleden in het nieuwe jaar, en is het rendement van Amerikaanse obligaties met verschillende looptijden gestegen. De cumulatieve stijging van 10-jarige Amerikaanse staatsobligaties deze week is ongeveer 18 basispunten, en de cumulatieve stijging van 2-jarige Amerikaanse staatsobligatierentes is ongeveer 24 basispunten.</p>
<p>De functionarissen van de Federal Reserve zijn op het podium gekomen om de verwachtingen van renteverlagingen te onderdrukken. Gullsby van de Federal Reserve zei dat de inflatiegegevens de koers van de rente zullen bepalen en dat een afname van de inflatie de deur zal openen naar renteverlagingen. Als de voortgang van de inflatie echter omkeert, kunnen renteverhogingen nodig zijn. Bostic wees er ook op dat hij hoopt op gestage vooruitgang naar het streefcijfer van 2% voordat er renteverlagingen plaatsvinden. Daley is van mening dat het te vroeg is om een overwinning op inflatie aan te kondigen en een aanstaande renteverlaging.</p>
<p>In de atmosfeer van de Federal Reserve die de renteverlagingen onderdrukt, steeg de Amerikaanse dollar cumulatief sinds het begin van het jaar met meer dan 0,8% deze week. Goud behaalde zijn slechtste wekelijkse prestatie sinds begin december. De olieprijzen zijn deze week met ongeveer 1% gestegen, terwijl de olieprijzen met 0,34% zijn gestegen. De situatie in de Rode Zee en het Midden-Oosten blijft de olieprijzen opdrijven. De onverwachte daling van de ruwe olievoorraden vorige week door het Amerikaanse ministerie van Energie is ook een belangrijke factor, en sommige economische gegevens hebben zorgen opgewekt over het vraagperspectief op de oliemarkt.</p>
<p>Deze week kan onze focus op Amerikaanse BBP- en PCE-gegevens een vroeg inzicht geven in de beleidsrichting van de Federal Reserve.</p>
<p>Volgens mediane schattingen van Bloomberg-enquêtes verwachten economen dat het eerste Q4 BBP van de Verenigde Staten een jaarlijkse groei van 2% zal laten zien. Hiermee wordt de groei van 4,9% in het derde kwartaal voortgezet en worden de sterkste opeenvolgende kwartalen van groei sinds 2021 gemarkeerd. Op dezelfde dag zullen uit gegevens naar verwachting blijken dat de kern-PCE die de voorkeur heeft van de Federal Reserve met 3% is gestegen in het jaar dat eindigde in december vorig jaar, wat de 11e opeenvolgende maand is van een vertraging van de jaarlijkse prijsgroei.</p>
<p>Bloomberg-economen zeiden: “Onze voorspelling betekent dat het BBP van de VS in 2023 een sterke groei zal behouden, met een verwacht groeipercentage van 2,7%, een aanzienlijke stijging ten opzichte van 0,7% in 2022. Echter, gezien de zorgen over de snelle afkoeling van de arbeidsmarkt, beschikbaarheid van krediet en duurzaamheid van de consumentenvraag, geloven we dat de groei in de eerste helft van dit jaar aanzienlijk zal vertragen.”</p>
<p>Als de aankomende initiële PMI en de daadwerkelijke persoonlijke uitgavenindicatoren in de Verenigde Staten veerkracht tonen in de Amerikaanse economie, kan dit vragen oproepen over de duur van de hoge inflatie, vergelijkbaar met recente non-farm arbeidsrapporten en CPI-gegevens.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<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 juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>