RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBlbiBFVEggc3RpamdlbiwgY3J5cHRvIG1hcmt0IHdvcmR0IHZlcmhpdDsgSGFja2VycyBoZWJiZW4gR0FMQSBHYW1lcyBhYW5nZXZhbGxlbiBlbiAkMjAwTSBHQUxBIFRva2VucyBnZW11bnQ7IE5hc2RhcSBJbmRleCBiZXJlaWt0IGVlbiBoaXN0b3Jpc2NoIGhvb2d0ZXB1bnQ=

2024-05-21, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/17162629051_13.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20ETFs20hebben20het20potentieel20om20BTC20boven20de207100020te20duwen20en20ETH20naar20een20twee20maanden20hoog20te20laten20stijgen20Hackers20hebben20GALA20Games20aanglen20en2020020miljoen20GALAtokens20gecreerd95142"><a name="Crypto Dagelijkse Samenvatting: ETF’s hebben het potentieel om BTC boven de $71.000 te duwen en ETH naar een twee maanden hoog te laten stijgen; Hackers hebben GALA Games aanglen en $200 miljoen GALA-tokens gecreëerd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: ETF’s hebben het potentieel om BTC boven de $71.000 te duwen en ETH naar een twee maanden hoog te laten stijgen; Hackers hebben <a href="/price/gala-gala" target="_blank" class="blog_inner_link">GALA</a> Games aanglen en $200 miljoen GALA-tokens gecreëerd.</h2><p>Laten we eerst de handelsactiviteiten van nader onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 20 mei een instroom van $9,3 miljoen aan fondsen. Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $64 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $24 miljoen, en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) $68,3 miljoen.</p>
<p>Volgens gegevens van CoinShares, trokken digitale activa-investeringsproducten van 13 tot 17 mei een nettostroom van $932 miljoen aan, wat duidt op investeerders’ <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over het vertragen van inflatoire druk. Ondanks een hoge nettostroom blijft het wekelijkse handelsvolume relatief laag op $10,5 miljard, een daling ten opzichte van $40 miljard in maart.</p>
<p>Grayscale’s Bitcoin ETF zag deze week een kleine instroom van fondsen, totaal $18 miljoen. Sinds januari is er $16,6 miljard uit het fonds gestroomd. Vanuit regionaal perspectief bedroeg de uitstroom van fondsen uit Hong Kong en Canada respectievelijk $83 miljoen en $17 miljoen.</p>
<p>Het grootste hoogtepunt van de markt van vandaag is de plotselinge stijging van ETH en BTC, waarbij de Ethereum-prijzen stijgen naar een twee maanden hoogtepunt van $3,700, doordat analisten hun verwachtingen aanzienlijk hebben verhoogd voor de mogelijke goedkeuring van spot ETH ETFs.</p>
<p>Na het verhogen van de goedkeuringskans van Eric Balchunas, een senior analist bij Bloomberg, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Nadat de Exchange Traded Funds (ETF’s) van 25% naar 75% zijn gestegen, steeg de aandelenkoers met meer dan 18%. Balchunas wees erop dat de Amerikaanse Securities and Exchange Commission mogelijk politieke druk zal ondervinden, aangezien hun eerdere standpunt wees op beperkt contact met ETF-aanvragers.</p>
<p>Analisten vermeldden verder dat volgens berichten de Amerikaanse Securities and Exchange Commission verzoeken doet aan beurzen zoals de New York Stock Exchange en Nasdaq om hun indieningsdocumenten bij te werken. Regulerende autoriteiten hebben dit nog niet officieel bevestigd. Nate Geraci, mede-oprichter van het ETF Institute en voorzitter van de ETF Store, verklaarde echter dat de registratievereisten voor individuele fondsen (S-1) nog steeds in afwachting zijn van een definitieve beslissing.</p>
<p>De BTC-prijs brak ook sterk door de belangrijke weerstandszone van $70.000, steeg met meer dan 8% en testte zelfs het weerstandsniveau van $72.000. De prijs heeft een nieuw wekelijks hoogtepunt van $71.896 bereikt en consolideert zijn winsten.</p>
<p>Volgens NewsBTC-monitoring is de prijsstijging deze keer veel hoger dan het Fibonacci retracementniveau van 23,6% tussen het hoogste punt van $66.047 en $71.896. Op de uurgrafiek van het valutapaar BTC/USD is een stijgende trendlijn gevormd, die de positie ondersteunt op $70.500.</p>
<p>Op dit moment ondervindt de prijs weerstand rond $71.850, waarbij het eerste belangrijke weerstandsniveau mogelijk rond $72.000 ligt en het volgende belangrijke weerstandsniveau mogelijk rond $72.500. Als de prijs significant door het weerstandsniveau van $72.500 breekt, kan het verder stijgen en het weerstandsniveau van $73.200 testen. Daarentegen, als de bulls er niet in slagen om door het weerstandsniveau van $72.000 te breken, kan er een kortetermijndaling optreden.</p>
<p>Het <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> gaming-platform Gala Games heeft mogelijk kwetsbaarheden ondervonden, wat heeft geleid tot verliezen van meer dan $200 miljoen. Hackers die hebben aanglen <a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> De aanvaller heeft 5 miljard tokens ter waarde van ongeveer $206 miljoen aangemaakt. Het lijkt erop dat de aanvaller ook de aangemaakte GALA-tokens heeft omgewisseld voor ETH, waardoor er grote chaos ontstond.</p>
<p>Na het incident daalde de prijs van GALA met 5,77% binnen één dag, en de inheemse token van het platform, GALA, kelderde met bijna 15%. Momenteel heeft GALA een marktwaarde van $1,7 miljard met een oplage van 40,6 miljard munten.</p>
<h2 id="h2-Markttrends20ETH20steeg20met20meer20dan202020terwijl20altcoins20over20het20algemeen20stegen86374"><a name="Markttrends: ETH steeg met meer dan 20%, terwijl altcoins over het algemeen stegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: ETH steeg met meer dan 20%, terwijl altcoins over het algemeen stegen</h2><p>BTC (Bitcoin): Doorbrak $71.000 en vertoont sterke opwaartse momentum.</p>
<p>ETH (Ethereum): Steeg ‘s nachts met meer dan 20% en bereikte een dagelijkse hoogte van meer dan $3700, in de buurt van zijn eerdere hoogtepunt.</p>
<p>Altcoins: Gedreven door BTC en ETH, stegen Altcoins.</p>
<p>Aandelen in de VS: deze blijven stijgen en bereiken een historisch hoogtepunt.</p>
<p>US-dollar index: Wekelijkse daling kan ondersteuning bieden voor de cryptomarkt.</p>
<h3 id="h3-Markt20Hotspots905048"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>ETH spot ETF</strong><br>De Amerikaanse Securities and Exchange Commission (SEC) vraagt om een versnelde update van de documenten voor de ETH ETF-aanvraag.</p>
<p>De kans op goedkeuring van de ETF-aanvraag is gestegen van 25% naar 75%.</p>
<p>De uiterste deadline voor het goedkeuren van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF’s is 7 augustus en ze kunnen al op 23 mei worden goedgekeurd.</p>
<p><strong>Ethereum Staking Sector</strong><br>PENDLE, ETHFI, REZ, LDO, ENA: Deze tokens die verband houden met staking vertonen ook een significante prestatie met de stijging van ETH.</p>
<p><strong>Meme Sector</strong><br>PEPE en MOG zijn gestegen, wat wijst op speculatieve interesse in meme-tokens op de markt.</p>
<p><strong>Laag 2</strong><br>METIS: Met een stijging van meer dan 30% heeft de Layer2-oplossing meer aandacht gekregen op de markt.</p>
<p><strong>Ethereum Domeinnaamprotocol</strong><br>ENS: Met een stijging van meer dan 30% profiteert ook de domeinnaamovereenkomst van de sterke prestaties van Ethereum.</p>
<p><strong><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosysteem</strong><br>PYTH en BONK: stijging tot grote hoogte, vooral na voltooien van een enorme tokenontgrendeling; PYTH kan stijgen in plaats van dalen. PYTH kan deze gelegenheid aangrijpen om zendingen op te trekken, dus voorzichtigheid is geboden.</p>
<p>Over het algemeen is het huidige marktsentiment relatief optimistisch, vooral met de sterke prestaties van ETH en BTC die de gehele cryptomarkt omhoog stuwen. Toch moeten investeerders nog steeds letten op marktvolatiliteit en potentiële risico’s, met name op het gebied van speculatief gedrag in sommige tokens en de marktreactie na het ontgrendelen van tokens.</p>
<h2 id="h2-Macro20De20Nasdaq20index20bereikte20een20historisch20hoogtepunt20terwijl20technologieaandelen20stegen20vr20het20financile20rapport20van20Nvidia642122"><a name="Macro: De Nasdaq index bereikte een historisch hoogtepunt, terwijl technologieaandelen stegen vóór het financiële rapport van Nvidia." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Nasdaq index bereikte een historisch hoogtepunt, terwijl technologieaandelen stegen vóór het financiële rapport van Nvidia.</h2><p>Op maandag 20 mei 2024 sloot de Nasdaq-index op een historisch hoog niveau in de Verenigde Staten, terwijl de S&amp;P 500-index iets steeg, voornamelijk als gevolg van de stijging van technologieaandelen voorafgaand aan het zeer verwachte financiële rapport van Nvidia en investeerdersspeculatie over het tijdstip van de renteverlaging door de Federal Reserve.</p>
<p>Volgens de laatste gegevens daalde de Dow Jones-index met 0,49%, steeg de S&amp;P 500-index met 0,09% en steeg de Nasdaq-index met 0,65%.</p>
<p>Onder de 11 belangrijkste sectoren van de S&amp;P 500-index leidde de technologie-index de stijging, met een stijging van 1,32%, voornamelijk gedreven door chipfabrikanten zoals Nvidia.</p>
<p>De aandelenkoers van Nvidia steeg met 2,49% voordat het op woensdag kwartaalresultaten bekendmaakte. De aandelenkoers van Nvidia steeg als gevolg van effectenbedrijven die hun winstverwachtingen verhoogden voordat ze op woensdag resultaten bekendmaakten; Micron Technology, een concurrerend bedrijf, zag ook een stijging. Nadat Morgan Stanley de waardering van deze opslagchipfabrikant verhoogde van “onderwogen” naar “neutraal”, steeg de aandelenkoers van het bedrijf met 2,96%. De PHLX-semiconductorindex steeg met 2,15%.</p>
<p>Het sterke winstseizoen en tekenen dat de inflatie weer kan afkoelen, hebben de hoop aangewakkerd dat de Federal Reserve dit jaar de rente zal verlagen, waardoor de primaire gemiddelde index naar een historisch hoogtepunt stijgt. De blue-chip Dow Jones-index sloot vorige week voor het eerst boven de 40.000 punten.</p>
<p>Volgens gegevens van de London Stock Exchange zijn recente winsten begonnen zorgen te baren over de aandelenwaarderingen, met de forward P/E-ratio van de S&amp;P 500-index op 20,8, ver boven het historisch gemiddelde van 15,9.</p>
<p>Recente winsten hebben echter zorgen doen rijzen over de waardering van aandelen, met de voorwaartse K/W-verhouding van de S&amp;P 500-index op 20,8, ver boven het historische gemiddelde van 15,9.</p>
<p>De opmerkingen van functionarissen van de Federal Reserve op maandag hebben de verwachtingen van een renteverlaging van de centrale bank nauwelijks veranderd, waarbij sommige functionarissen benadrukken dat er voorzichtigheid betracht moet worden. Volgens de FedWatch-tool van CME verwacht de markt een kans van 63,3% op een renteverlaging van minimaal 25 basispunten (bps) bij de vergadering in september.</p>
<p>Terwijl beleggers wachtten op de notulen van de laatste beleidsvergadering van de Federal Reserve om het tijdstip en de omvang van mogelijke renteverlagingen dit jaar te beoordelen, daalden de Aziatische aandelenmarkten op dinsdag, terwijl de Amerikaanse dollar sterker werd. De MSCI Asia Pacific Stock Index is meer dan 1% gedaald vanaf zijn hoogtepunt van enkele maanden op maandag, terwijl de Hang Seng Index met 0,6% is gedaald.</p>
<p>Na voor het eerst de grens van $2450 te hebben bereikt, daalden de goudprijzen met 0,2% naar ongeveer $2.420 per ounce.</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 beleggingsadviezen.<br></em><div><em></em> Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>