RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZWVmdCBlZW4ga2FucyB2YW4gMjAlIG9tIGVpbmQgYXByaWwgZGUgJDcwSyB0ZSBvdmVyc2NocmlqZGVuOyBEYWdlbGlqa3MgYWN0aWV2ZSBnZWJydWlrZXJzIHZhbiBkZSBXb3JsZCBBUFAgb3ZlcnNjaHJpamRlbiAxIG1pbGpvZW47IE1lZXIgZGFuICQ0MDBNIGFhbiBBVkFYIGVuIGFuZGVyZSB

2024-02-22, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/17085740421_15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Blue20Whale20Houdt20Meer20Dan201200020ETHs20Vast20Financieel20Rapport20Van20NVIDIA20Triggert20Een20Sterke20Opleving20In20AItokens506870"><a name="Crypto Dagelijkse Samenvatting: Blue Whale Houdt Meer Dan 12.000 ETHs Vast, Financieel Rapport Van NVIDIA Triggert Een Sterke Opleving In AI-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Blue Whale Houdt Meer Dan 12.000 ETHs Vast, Financieel Rapport Van NVIDIA Triggert Een Sterke Opleving In AI-tokens</h2><p>Laten we eerst kijken naar de verkoopdruk van gisteren in grayscale. Volgens de monitoring van Arkham heeft grayscale om 22:11 uur Beijing-tijd op 21 februari 3164,672 BTC overgedragen, met een waarde van ongeveer $161 miljoen, naar het adres van Coinbase Prime. Bovendien zal grayscale 1674,8 bitcoins overdragen naar twee nieuwe adressen, die vermoedelijk de nieuwe hostingadressen van grayscale zijn.</p>
<p>Op 21 februari, de Grayscale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF GBTC had een netto-uitstroom van ongeveer $199 miljoen. Volgens monitoring van Farside Investors had ARK 21Shares een nettostroom van $10,7 miljoen in ARKB-fondsen en had Franklin’s EZBC een nettostroom van $3 miljoen. Volgens de gegevens van SoSoValue hadden <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s op 20 februari, Eastern Time, een totale nettostroom van $135 miljoen, waarmee ze gedurende 17 opeenvolgende handelsdagen nettostromen behaalden.</p>
<p>Gisteren had de Grayscale ETFGBTC een nettodagelijkse uitstroom van $137 miljoen. De Bitcoin spot ETF met de hoogste dagelijkse nettostroom gisteren was Black Rock ETFIBIT, met een dagelijkse nettostroom van $154 miljoen. Momenteel heeft IBIT’s totale historische nettostroom $5,52 miljard bereikt. Er wordt gemeld dat IBIT 122.643,5176 BTC’s vasthoudt, en de Bitcoin-activa hebben een marktwaarde van meer dan $6,3 miljard.</p>
<p>Als volgende is Fidelity ETF - FBTC, met een dagelijkse nettostroom van ongeveer $71.74 miljoen. Momenteel heeft FBTC’s totale historische nettostroom $3.84 miljard bereikt. Op het moment van publicatie bedroeg de totale netto-activawaarde van Bitcoin spot ETF’s $37.93 miljard, en de netto-activaverhouding van ETF’s (marktwaarde in vergelijking met de totale marktwaarde van Bitcoin) bereikte 3.72%. De cumulatieve nettostroom in de geschiedenis heeft $5.18 miljard bereikt.</p>
<p>Volgens een update die door 21Shares op het X-platform is uitgebracht, heeft de spot Bitcoin ETF (ARKB) vandaag $10.717.400 aan nettomiddelen gegenereerd, met een totaal handelsvolume van $1.381.979.460 in de afgelopen 10 dagen, waardoor het een van de best presterende spot Bitcoin ETF’s is in februari 2024.</p>
<p>Er wordt gemeld dat elke Pudgy-speelgoed wordt geleverd met een QR-code, die kan worden gebruikt om toegang te krijgen tot het multiplayer digitale sociale platform Pudgy World, waar gebruikers hun eigen ‘Forever Pudgy’-personages kunnen bouwen, mini-games kunnen spelen en kunnen communiceren met andere gebruikers. Pudgy World is gebaseerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer2-netwerk zkSync Era en bevindt zich momenteel in de publieke bèta-modus.</p>
<p>Wat betreft de tokenmarkt, volgens Gate.io-marktgegevens is er de laatste tijd een algemene daling van valse munten te zien, volgend op de markttrend. Eerder hebben sterke cryptocurrencies zoals OP met een hoge marktwaarde een daling van meer dan 10% in 24 uur meegemaakt. Onder hen wordt OP momenteel genoteerd op $3,62, een daling van 11,98% in 24 uur; NEAR wordt momenteel genoteerd op $3,11, een daling van 8,98% binnen 24 uur; AVAX wordt momenteel genoteerd op $36,44, een daling van 6,68% binnen 24 uur; SOL wordt momenteel genoteerd op $101,71, een daling van 6,69% binnen 24 uur.</p>
<p>Op 21 februari, volgens monitoring van @ai_9684xtpa, heeft een enorme walvis in de afgelopen 20 minuten 12.738 ETH (ter waarde van $36,9 miljoen) gekocht via <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> en Binance, met een gemiddelde aankoopprijs van $2897. Op dit moment heeft de gigantische walvis 106.159 ETH’s in bezit, ter waarde van $308 miljoen.</p>
<p>Het financiële rapport van Nvidia werd gisteren uitgebracht, waar de wereldwijde kapitaalmarkt halsreikend naar uitkeek. Volgens Decrypt toonde het recente financiële rapport van NVIDIA aan dat de omzet in het vierde kwartaal $22,1 miljard bedroeg, een stijging van 265% ten opzichte van het voorgaande jaar, ruim boven de verwachtingen van de markt. De nettowinst in Q4 bedroeg $12,285 miljard, hoger dan de marktverwachtingen van $10,34 miljard.</p>
<p>Deze groei is voornamelijk te danken aan de snelle ontwikkeling van kunstmatige intelligentie technologie, met name in versnelde computing en generatieve AI. De aandelenkoers van NVIDIA steeg met 8% in de handel na sluitingstijd, wat wijst op optimistische marktverwachtingen voor de toekomstige ontwikkeling van kunstmatige intelligentie technologie. NVIDIA-oprichter en CEO Huang Renxun verklaarde dat de AI-industrie een “kantelpunt” had bereikt.</p>
<p>Nadat NVIDIA haar financieel rapport vrijgaf, schoten AI-tokens omhoog. SingularityNet (AGIX) steeg met meer dan 20%, FetchAI (FET) steeg met meer dan 10%. <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Renderen</a> steeg met meer dan 10%, RNDR steeg met 8% en WLD steeg met meer dan 18%. Volgens CoinGecko-gegevens heeft de totale marktwaarde van AI-tokens $ 16,5 miljard overschreden.</p>
<p>Wat betreft de NFT-markt hebben de twee toonaangevende NFT-projecten onlangs veel aandacht van de markt getrokken.</p>
<p>Op 22 februari steeg volgens Blur-gegevens de vloerprijs van het NFT-project BoredApeYachtClub (BAYC) met 5,30% in één dag en wordt nu genoteerd op 22,85 ETH. Eerder vandaag kondigde Greg Solano, medeoprichter van Yuga Labs, in een bericht aan dat hij opnieuw zal dienen als CEO van Yuga Labs, terwijl een nieuw bedrijf genaamd ‘BAYC LLC’ is opgericht als dochteronderneming van Yuga en verantwoordelijk zal zijn voor alle BAYC-gerelateerde zaken. In de toekomst hoopt Greg de BAYC-teams van Yuga zo veel mogelijk te bevrijden, hen in staat te stellen hun visie uit te voeren en het meer gefocust en flexibel te maken.</p>
<p>Bovendien komt Fat Penguin agressief op. Sinds de minimumprijs BAYC heeft overtroffen, zijn er nieuwe ontwikkelingen geweest. Volgens mediaberichten heeft Walmart, ‘s werelds grootste detailhandelaar, het aanbod van Pudgy Toys (NFT-serie Pudgy Penguins-speelgoedserie) uitgebreid naar 1.100 winkels in de Verenigde Staten, waardoor het totale aantal winkels in het hele land op 3.100 komt.</p>
<p>Naar verluidt heeft Walmart 30 nieuwe Pudgy-speelgoed gelanceerd, waaronder Lil Pudgys Igloo-verzamelitems en beweegbare poppen, elk geprijsd tussen $2.99 en $11.97. Pudgy Toys maakte vorig september zijn debuut bij Walmart, aanvankelijk in 2.000 Amerikaanse winkels.</p>
<h2 id="h2-Macro20De20Fed20onderdrukt20verwachtingen20van20renteverlagingen20goud20zakte20op20een20gegeven20moment20onder20de20202020drempel389994"><a name="Macro: De Fed onderdrukt verwachtingen van renteverlagingen, goud zakte op een gegeven moment onder de $2.020 drempel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Fed onderdrukt verwachtingen van renteverlagingen, goud zakte op een gegeven moment onder de $2.020 drempel</h2><p>Op woensdag schommelde de Amerikaanse dollar index rond het niveau van 104 en sloot uiteindelijk met een daling van 0,073% op 103,99. Na de aankondiging van de veilingresultaten van de Amerikaanse 20-jarige schatkist obligaties, steeg het Amerikaanse obligatierendement, steeg het referentie 10-jaars Amerikaanse obligatierendement weer tot 4,30% en sloot het 2-jaars Amerikaanse obligatierendement, dat het meest gevoelig is voor het beleidsrente van de Federal Reserve, op 4,651%.</p>
<p>Als gevolg van de afnemende hoop op vroegtijdige renteverlagingen in de notulen van de Federal Reserve-vergadering, daalde de spotprijs van goud op korte termijn en zakte onder het niveau van 2020, om uiteindelijk met 0,08% te sluiten op $2025,99 per ounce; spotzilver daalde onder de 23 mark en sloot uiteindelijk met 0,53% lager op $22,89 per ounce.</p>
<p>De internationale ruwe olie herstelt zich doordat handelaren de tekenen van een aanscherping van het aanbod op de spotmarkt voor ruwe olie afwegen. WTI-ruwe olie steeg met 1,1% tot $77,98 per vat; Brent-ruwe olie steeg met 0,76% tot $83,09 per vat. Wat betreft aardgas, zijn de Amerikaanse aardgas-futures op de dag met 12% gestegen.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices hebben gemengde winsten en verliezen, waarbij de Dow Jones en S&amp;P 500 iets hoger sluiten en de Nasdaq met 0,3% daalt.</p>
<p>Gisteravond heeft de Federal Reserve de notulen van de monetaire beleidsvergadering van januari vrijgegeven. Uit de notulen blijkt dat functionarissen van de Federal Reserve van mening zijn dat het rentebeleid mogelijk de top van deze cyclus heeft bereikt. Toch zijn de meeste functionarissen zich bewust van het risico van een te snelle renteverlaging, en sommige functionarissen zien het risico dat de vooruitgang in de inflatie mogelijk stagneert, waarbij de inflatieverwachtingen enigszins omhoog neigen.</p>
<p>Sommige Fed-functionarissen suggereren dat het vertragen van het tempo van het aanscherpen van de balans kan zorgen voor een soepelere overgangsperiode. Ze hebben een afname opgemerkt in het gebruik van overnight reverse repos, en veel functionarissen hebben aangegeven dat het gepast is om diepgaande discussies te beginnen over de balans tijdens de volgende vergadering. Sommige beleidsmakers suggereren dat het vertragen van het tempo van schaalvermindering kan zorgen voor een langere periode van schaalvermindering.</p>
<p>Medewerkers van de Federal Reserve wezen erop dat het consensus op Wall Street is dat de vertraging van QT in juli zal beginnen, hoewel er aanzienlijke onzekerheid bestaat over de exacte startdatum. De kern van het debat is in hoeverre de Federal Reserve haar balans kan verkleinen zonder chaos op de financiële markten te veroorzaken of haar bredere beleidsdoelstellingen te ondermijnen. Tot nu toe is sinds het begin van QT in juni 2022 haar balans met ongeveer $1,3 biljoen gekrompen.</p>
<p>Bovendien verklaarde Federal Reserve-directeur Bauman dat dit ‘absoluut niet’ het moment is om de rente te verlagen, en de vastgoedmarkt belemmert de beslissing om de rente te verlagen niet. Richmond Fed-voorzitter Barkin is ook van mening dat januari-gegevens in evenwicht moeten worden gebracht met informatie uit die maand vanwege seizoensgebonden kwesties, en er wordt verwacht dat bedrijven de prijzen zullen verhogen.</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 opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>