RGFnZWxpamtzIG5pZXV3cyB8IERlc2NpIENvbmNlcHQgTGVhZGluZyBUb2tlbiBSSUYgc3RlZWcgbWVlciBkYW4gZHVpemVuZCBrZWVyIGluIGphbnVhcmksIHdvcmR0IGhldCBlZW4gbmlldXcgdmVyaGFhbCBvcCBkZSBtYXJrdD8=

2024-11-19, 04:46

<p><img src="https://gimg2.gateimg.com/image/article/173199147811.19.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Magic20Eden20heeft20ME20token20economie20aangekondigd20cryptomarkt20betreedt20een20uiterst20hebzuchtige20staat765611"><a name="Crypto Dagelijks Overzicht: Magic Eden heeft ME token economie aangekondigd, cryptomarkt betreedt een uiterst hebzuchtige staat" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Magic Eden heeft ME token economie aangekondigd, cryptomarkt betreedt een uiterst hebzuchtige staat</h2><p>Volgens de gegevens van Farside Investor was er gisteren een nettostroom naar de VS. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De totale instroom in spot ETF’s was $255 miljoen, inclusief $90 miljoen van BlackRock IBIT, $60 miljoen van Fidelity FBTC en $54 miljoen van Grayscale Mini Trust BTC.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s kenden een uitstroom van $15,1 miljoen. De uitstroom van Grayscale ETHE was $13,3 miljoen, en de gegevens van BlackRock ETHA zijn nog niet vrijgegeven.</p>
<p><strong>Magic Eden heeft de token economie aangekondigd: initiële airdrop percentage van 12.5%</strong></p>
<p>Magic Eden heeft zijn ME-token-economie aangekondigd, met in totaal 1 miljard ME-tokens die over 4 jaar worden verdeeld, waarvan 50,2% aan de gemeenschap zal worden toegewezen. Het totale percentage gemeenschappen en ecoen is 37,7%, en de initiële toewijzing van gemeenschappen zal 12,5% van het totale aanbod bedragen. Daarnaast is het percentage bijdragers 26,2% en het percentage strategische deelnemers 23,6%, inclusief vergrendelingsperioden. Magic Eden heeft aangekondigd dat het binnenkort een luchtdruppelinspectiewebsite zal lanceren, maar heeft nog geen specifieke datum opgegeven.</p>
<p><strong>De Crypto Panic &amp; Greed Index steeg naar 90 en blijft in een ‘extreem hebzuchtige staat’.</strong></p>
<p>Volgens gegevens van Alternative.me is de Crypto Panic &amp; Greed-index vandaag gestegen naar 90 (van 83 gisteren), wat aangeeft dat de markt nog steeds in een ‘extreem hebberige staat’ verkeert.</p>
<p>Opmerking: De drempel voor de paniekindex is 0-100, inclusief indicatoren zoals volatiliteit (25%) + handelsvolume op de markt (25%) + populariteit op sociale media (15%) + marktonderzoek (15%) + het aandeel van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> op de gehele markt (10%) + Google-zoekwoordanalyse (10%).</p>
<p><strong>Nvidia zal deze woensdag haar financiële rapport aankondigen en handelaren wedden dat de aandelen met 12% zullen fluctueren nadat het rapport is vrijgegeven.</strong></p>
<p>Volgens gegevens van de Chicago Board Options Exchange wedden handelaren erop dat de aandelen van Nvidia met ongeveer 12% zullen stijgen of dalen op de volgende handelsdag na de publicatie van het financiële rapport, wat resulteert in een marktwaardeschommeling van ongeveer $407 miljard. Vishal Vivek, een aandelen- en derivatenhandelstrateeg bij Citigroup, verklaarde dat de aandelenkoers van Nvidia gemiddeld meer dan 9% is geschommeld na de publicatie van zijn kwartaalcijfers op basis van de afgelopen acht verdienstdagen.</p>
<p>Er wordt gemeld dat investeerders zich voorbereiden op nog een aanzienlijke stijging van het Nvidia-aandeel. Ze kopen een groot aantal optiecontracten, die rendement zullen opleveren als de aandelenprijs van Nvidia deze week met meer dan 10% stijgt.</p>
<h2 id="h2-Markttrends20Desciconcept20RIF20en20URO20stegen20sterk20en20de20korte20termijn20markt20kan20voor20een20aanpassing20staan577849"><a name="Markttrends: Desci-concept RIF en URO stegen sterk, en de korte termijn markt kan voor een aanpassing staan." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Desci-concept RIF en URO stegen sterk, en de korte termijn markt kan voor een aanpassing staan.</h2><h3 id="h3-Markt20Hotspots670005"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De meme-projecten URO, RIF, BAN en anderen op de keten zijn gestegen. RIF en URO zijn de toonaangevende tokens van het Desci-concept en RIF is in de afgelopen maand meer dan 1000 keer gestegen. RIF komt van het Pump.science-platform en vertegenwoordigt de <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">verbinding</a> rifampicine (RIF). Pump.science is een Meme coin platform gelanceerd door het Desci-project Molecular DAO, dat medische experimenten ondersteunt via Meme coins. Pump Science verklaart officieel dat alleen $RIF/$URO echt officiële tokens zijn;</p>
<p>In de vroege fase van de huidige Amerikaanse verkiezingen ondergingen toonaangevende tokens zoals PNUT en ACT een scherpe daling, waardoor ze als eerste in de aanpassingsfase terechtkwamen. Wanneer de toonaangevende tokens hun hoogtepunt bereiken en dalen, geeft dit aan dat de markt mogelijk het risico loopt op een neerwaartse aanpassing op korte termijn.</p>
<h3 id="h3-Mainstream20Munten10562"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC consolideerde rond de $91.000, waarbij BTC ETF’s vorige week twee opeenvolgende dagen aanzienlijke uitstromen hadden. Gisteren hervatten de fondsen positieve instroom en BTC wacht om door de psychologische barrière van $100.000 te breken;</p>
<p>ETH schommelde nauw voor $3.000 en $3.200, en het kan alleen onafhankelijke prestaties hebben nadat BTC een historisch hoogtepunt bereikt;</p>
<p>Altcoins daalden over het algemeen en de markt ontbeert nog steeds aanhoudende hotspots. De stijging is voornamelijk te wijten aan kleine marktkapitaal memes op de keten, en VC-tokens met een lage circulatie en een hoge marktkapitaal worden nog steeds niet begunstigd door fondsen.</p>
<h2 id="h2-Macro20nieuws20De20drie20belangrijkste20Amerikaanse20aandelenindexen20waren20wisselend20en20de20markt20richt20zich20op20het20financile20rapport20van20Nvidia20op20woensdag424403"><a name="Macro nieuws: De drie belangrijkste Amerikaanse aandelenindexen waren wisselend, en de markt richt zich op het financiële rapport van Nvidia op woensdag." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: De drie belangrijkste Amerikaanse aandelenindexen waren wisselend, en de markt richt zich op het financiële rapport van Nvidia op woensdag.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,39% steeg tot 5.893,62 punten; De Dow Jones Industrial Average daalde met 0,13% tot 43.389,60 punten; De Nasdaq-index steeg met 0,60% tot 18.791,81 punten. Het referentiepunt van de 10-jaars Treasury-rente is 4,42%, terwijl de 2-jaars Treasury-rente, het meest gevoelig voor het rentetarief van de Federal Reserve, 4,29% is.</p>
<p>De Amerikaanse aandelenmarkt Bakkt steeg met 162,46%, wat vijf keer circuitonderbrekingen veroorzaakte. Op het nieuwsfront meldt de Financial Times dat het socialemediabedrijf van Trump in diepe onderhandelingen is om Bakkt over te nemen, een crypto-handelsplatform onder de Intercontinental Exchange, aangezien het bedrijf streeft naar uitbreiding van zijn activiteiten buiten online gesprekken.</p>
<p>Strategen van Bank of America Securities voorspellen dat het financieel rapport van Nvidia, dat aanstaande woensdag zal worden vrijgegeven, grotere volatiliteit zal brengen dan de volgende gegevens over de non-farm payroll, consumentenprijsindex of Federal Reserve-beslissing.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</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 enkele beleggingssuggestie. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat 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>