RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gaG91ZHQgdmFzdCwgbWFya3QgdHJla3QgemljaCB0ZXJ1ZzsgZGUgdm9vcnZlcmtvb3B0cmVuZCB2YW4gTWVtZXMgb3AgU29sYW5hIHRyb2sgbWVlciBkYW4gJDEwMCBtaWxqb2VuIGFhbjsgU2F1ZGktQXJhYmnDqyByaWNodHRlIGVlbiBmb25kcyB2YW4gJDQwIG1pbGphcmQgb3Agb20gdGU

2024-03-20, 03:41

<p><img src="https://gimg2.gateimg.com/image/article/17109061691_14.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20houdingen20van20Bitcoin20nemen20af20wat20leidt20tot20marktcorrectie20De20presale20trend20van20memes20op20Solana20heeft20meer20dan2010020miljoen20fondsen20aangetrokken585853"><a name="Crypto Dagelijkse Samenvatting: De houdingen van Bitcoin nemen af, wat leidt tot marktcorrectie; De pre-sale trend van memes op Solana heeft meer dan 100 miljoen fondsen aangetrokken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De houdingen van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> nemen af, wat leidt tot marktcorrectie; De pre-sale trend van memes op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> heeft meer dan 100 miljoen fondsen aangetrokken</h2><p>Allereerst gaan we de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens de gegevens van Farside Investor, bleven op 19 maart de GBTC-fondsen van Grayscale doorgaan. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> De instroom van de Fidelity Bitcoin spot ETF (FBTC) bedroeg $39,66 miljoen en de instroom van de Bitwise Bitcoin spot ETF (BITB) bedroeg $2,5 miljoen. Intussen is de instroom van de Grayscale Bitcoin Trust (GBTC) aanzienlijk gedaald tot $443,5 miljoen.</p>
<p>Op 19 maart daalde de prijs van Bitcoin verder en bereikte een dieptepunt van ongeveer $61.500, met een daling van 5,4% in 24 uur. ETH staat momenteel op $3.208,57, een daling van 6,6%, met Altcoins die over het algemeen dalen. Dit komt voornamelijk doordat de meeste Bitcoin-houders geleidelijk winst nemen en Bitcoin verkopen, wat een typische prijsdaling voor de halvering is. Op de lange termijn blijven investeerders optimistisch over BTC en ETH.</p>
<p>Sinds $BOME de pre-sale modus is gestart en onverwachte hoeveelheden fondsen heeft ontvangen, zijn de tokenprijzen omhooggeschoten en zijn er steeds meer Altcoin-memes verschenen op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> achter elkaar, zoals de hete $SLERF (Gate heeft al $BOME en $SLERF tokens gelanceerd)</p>
<p>Slerf-ontwikkelaars boden hun excuses aan op sociale media nadat ze per ongeluk tokens hadden verbrand, wat in plaats daarvan leidde tot een golf van ‘viral gaan’. De aandacht van de gemeenschap leidde tot een stijging van de tokenprijzen, die op een gegeven moment $1,37 overschreed maar nu terugvalt naar $0,85.</p>
<p>Maar nu is er aanzienlijke controverse over de vraag of ontwikkelaars dit opzettelijk hebben gedaan. De ontwikkelaar ontkende het natuurlijk en verklaarde dat hij “niet van plan” was om het token te vernietigen. “Dit is een feit, maar ik ben niet van plan de gedropte tokens te verbranden”, schreef Slerf in een bericht dat op 19 maart naar X werd gestuurd.</p>
<p>Wildcat-maker Laurence Day verklaarde echter dat de verbranding van Slerf “vrijwel zeker opzettelijk” was om het project op te winden. Hij legde uit dat iemand kort na de vernietiging $1,9 miljoen in de liquiditeitspool had gestort en het voor $5 miljoen had verkocht, wat erop wijst dat insiders het incident mogelijk hebben gebruikt om te profiteren van hysterie.</p>
<p>Chain detective ZachXBT heeft een statistiek van een pre-sale project gemaakt en zei: “Ik was geïnteresseerd om te zien hoeveel SOL er als gevolg van de pre-sale meta is verzonden en berekende &gt;655.000 SOL ($122,5M) opgehaald uit 27 pre-sales.”</p>
<p>Hierover verklaarde Anatoly Yakovenko, medeoprichter van Solana, dat hij geen steun verleent aan pre-sales en stuurde Zach’s gegevens door, zeggende: ‘Stop hiermee.’</p>
<p>Op dinsdag heeft de Amerikaanse Securities and Exchange Commission (SEC) opnieuw de beslissing over de “spot” uitgesteld. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF” voorgesteld door Hashdex en ARK 21Shares. De definitieve beslissing van de SEC over ARK 21Shares is 24 mei, en de aanvraag van Hashdex zal vóór 30 mei een ultimatum van toezichthoudende autoriteiten tegemoet zien.</p>
<p>Analisten zijn niet optimistisch over de mogelijkheid van goedkeuring voor de acht <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s voorgesteld door BlackRock, Grayscale, Fidelity, Invesco Galaxy, VanEck, Hashdex en Franklin Templeton.</p>
<h2 id="h2-Markttrends20Altcoins20daalden20over20het20algemeen20wat20leidde20tot20een20aanzienlijke20toename20van20de20marktvolatiliteit951243"><a name="Markttrends: Altcoins daalden over het algemeen, wat leidde tot een aanzienlijke toename van de marktvolatiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Altcoins daalden over het algemeen, wat leidde tot een aanzienlijke toename van de marktvolatiliteit</h2><p>De markt kende in deze periode ernstige schommelingen, waarbij de BTC-prijzen bijna $61.000 naderden en ETH $3.100 naderde, terwijl Altcoins over het algemeen daalden. Daarnaast hebben BTC-spot ETF’s de trend van netto uitstroom voortgezet van de vorige dag, tijdelijk gebrek aan sterke aankopen zoals voorheen, en de aanvraag voor ETH ETF’s is ook vertraagd.</p>
<p>Met betrekking tot de macro-economie is de Amerikaanse aandelenmarkt volatiel geweest. Eerder had de markt verwacht dat de Federal Reserve de rente in juni zou verlagen, maar de kans op deze verwachting is drastisch afgenomen. Aan de andere kant kondigde de Bank of Japan de eerste renteverhoging in 17 jaar aan, waarmee een einde kwam aan het tijdperk van negatieve rentetarieven in yen. De algemene opvatting is dat een renteverhoging in yen onvermijdelijk invloed zal hebben op risicovolle activa.</p>
<h3 id="h3-Markt20hotspots126124"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>In het publieke ketengebied zijn projecten zoals FTM, APT en SUI toegenomen. Bijzondere vermelding verdient APT, dat op 12 april tokens ter waarde van $400 miljoen zal ontgrendelen. Over het algemeen zal er vóór het ontgrendelen van tokens een zekere prijsstijging zijn om de mogelijke druk van het verkopen van tokens na het ontgrendelen op te vangen.</p>
<p>Wat betreft Meme-conceptmunten heeft BOME een daling van 70% doorgemaakt na een hoogtepunt te hebben ervaren en is gestabiliseerd en hersteld. De 24-uurs handelsvolume van SLERF overtrof $2,69 miljard en trok de meeste aandacht van de markt. Ondertussen ontbreekt het steeds meer aan nieuwigheid bij de Meme-projecten op de Solana-keten.</p>
<p>Over het algemeen vertoont de markt een toenemende volatiliteitstrend, en moeten beleggers markthotspots en macro-economische trends nauwlettend in de gaten houden om overeenkomstige beleggingsstrategieën te ontwikkelen.</p>
<h2 id="h2-Macro20SaudiArabi20is20van20plan20om20een20fonds20van204020miljard20op20te20richten20om20te20investeren20in20kunstmatige20intelligentie20De20Japanse20yen20daalt20en20de20beleidsvergadering20van20de20Federal20Reserve20is20het20middelpunt20geworden491978"><a name="Macro: Saudi-Arabië is van plan om een fonds van $40 miljard op te richten om te investeren in kunstmatige intelligentie. De Japanse yen daalt en de beleidsvergadering van de Federal Reserve is het middelpunt geworden." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Saudi-Arabië is van plan om een fonds van $40 miljard op te richten om te investeren in kunstmatige intelligentie. De Japanse yen daalt en de beleidsvergadering van de Federal Reserve is het middelpunt geworden.</h2><p>Volgens de New York Times van dinsdag, verwijzend naar drie bronnen die bekend zijn met de zaak, is de Saoedische regering van plan een fonds van ongeveer $40 miljard op te richten om te investeren in kunstmatige intelligentie. In de afgelopen weken hebben vertegenwoordigers van het Saoedische Publieke Investeringsfonds (PIF) potentiële partnerschappen besproken met het Amerikaanse durfkapitaalbedrijf Andreessen Horowitz en andere financiers.</p>
<p>PIF-functionarissen bespraken ook de rol van Andreessen Horowitz en hoe het fonds zal opereren, waarbij wordt opgemerkt dat deze plannen nog steeds kunnen veranderen. De krant meldde dat andere durfkapitalisten mogelijk zullen deelnemen aan het kunstmatige intelligentie-fonds van het Koninkrijk, dat naar verwachting in de tweede helft van 2024 zal worden gelanceerd.</p>
<p>Op de wereldwijde markt ligt de focus nog steeds op Japan en de Federal Reserve; Japan was gesloten vanwege een feestdag, maar de verzwakking van de yen zorgde ervoor dat de Nikkei-index futures met 0,6% stegen. De dag ervoor beëindigde de Bank of Japan jaren van negatieve rentetarieven met een bekende zet. De Nikkei 225-index is teruggekeerd boven de 40.000 punten, slechts een stap verwijderd van zijn historische hoogtepunt van 40.472 punten eerder deze maand.</p>
<p>Met het vertrek van de Bank of Japan ligt de focus nu volledig op de uitkomst van de beleidsvergadering van de Federal Reserve later, met het risico dat de nieuwe economische prognose (het stippenplot) mogelijk slechts twee renteverlagingen voorspelt, te beginnen met beleidsondersteuning van drie of latere renteverlagingen. Vanwege recente gegevens waaruit blijkt dat de inflatie hardnekkig blijft, heeft de markt de eerste renteverlaging door de Federal Reserve uitgesteld tot juni, of zelfs juli.</p>
<p>Raskin verwacht dat de stippenplot en de informatie van voorzitter Powell van de Federal Reserve tijdens de persconferentie na de vergadering zullen neigen naar een ietwat havikachtige houding, wat ten goede zal komen aan de Amerikaanse dollar.</p>
<p>Het is twijfelachtig of Powell maatregelen zal nemen om het volledig geleide risico van de VS te verzwakken en een heroverweging van arbitrage rond de kortere yen, in plaats van lange Latijns-Amerikaanse obligaties met een hoog rendement.</p>
<p>Goldman Sachs verwacht dat de Federal Reserve zal blijven debatteren over het niveau van neutrale rentetarieven. De bank schat dat de lange termijn neutrale rentevoet ligt in het bereik van 3,25-3,5%, hoger dan de algemeen geloofde 2-2,5%. Sommige functionarissen hebben juni erkend als de maand waarin discussies over de renteverlaging van de Europese Centrale Bank kunnen beginnen.</p>
<p>De euro en Australische dollar stegen tegenover de Japanse yen op de valutamarkt. De euro/yen wisselkoers raakte 164,34 yen, het hoogste niveau sinds 2008, terwijl de Australische dollar/yen wisselkoers 98,72 yen was, iets lager dan een negenjarig hoogtepunt.</p>
<p>Met betrekking tot grondstoffen zijn de olieprijzen gedaald van enkele maanden van hoge niveaus als gevolg van de versterking van de Amerikaanse dollar. Brent ruwe olie daalde met 0,2% naar $87,19 per vat, terwijl Amerikaanse ruwe olie met 0,4% daalde naar $83,18 per vat.</p>
<p>De goudprijs bleef stabiel op $2.156,08 per ounce, met een aanzienlijke daling van het historische hoogtepunt van $2.194,99 eerder deze maand.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>