RGFnZWxpamtzIG5pZXV3cyB8IEVUSCBTcG90IEVURidzIGhlYmJlbiBvZmZpY2nDq2xlIGdvZWRrZXVyaW5nIHZhbiBkZSBTRUMgb250dmFuZ2VuLCBkZSBjcnlwdG9tYXJrdCBpcyB0ZXJ1Z2dldHJva2tlbjsgUGx1bWUgTmV0d29yayBoZWVmdCBlZW4gZmluYW5jaWVyaW5nIHZhbiAkMTAgbWlsam9lbiBhZmdlcm9uZC4=

2024-05-24, 03:45

<p><img src="https://gimg2.gateimg.com/image/article/17165221151_16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20spot20Ethereum20ETF20is20officieel20goedgekeurd20door20de20Amerikaanse20SEC20wat20de20instap20van20Bitcoin20in20een20lichte20daling20benvloedt20Plume20Network20heeft20succesvol20een20financiering20van201020miljoen20afgerond905125"><a name="Crypto Dagelijkse Samenvatting: De spot Ethereum ETF is officieel goedgekeurd door de Amerikaanse SEC, wat de instap van Bitcoin in een ‘lichte daling’ beïnvloedt; Plume Network heeft succesvol een financiering van $10 miljoen afgerond" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF is officieel goedgekeurd door de Amerikaanse SEC, wat de instap van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in een ‘lichte daling’ beïnvloedt; Plume Network heeft succesvol een financiering van $10 miljoen afgerond</h2><p>Allereerst, laten we eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens ondervonden Grayscale Bitcoin-spot ETF’s (GBTC) op 6 maart nog steeds uitstroom van $13,7 miljoen aan middelen; Ondertussen stroomde er $19,1 miljoen binnen bij Fidelity Bitcoin-spot ETF (FBTC) en $2 miljoen bij ARK 21Shares Bitcoin-spot ETF (ARKB).</p>
<p><strong>Spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF is officieel goedgekeurd door de Amerikaanse SEC</strong><br>De Securities and Exchange Commission (SEC) van de Verenigde Staten heeft de lancering van spot Ethereum Exchange Traded Funds (ETF’s) in de Verenigde Staten goedgekeurd.</p>
<p>Op 23 mei heeft de SEC het document “19b-4” goedgekeurd dat is ingediend door VanEck, BlackRock, Fidelity, Grayscale, Franklin Templeton, ARK 21Shares en Invesco Galaxyand Bitwise, waarbij de SEC een regelwijziging heeft goedgekeurd die het mogelijk maakt om spot Ethereum ETF’s te noteren en verhandelen op hun respectieve beurzen. Hoewel sommigen speculeren dat effectenregulatoren hebben onderzocht of ETH als effect moet worden gemarkeerd, heeft de Amerikaanse Securities and Exchange Commission deze mijlpaalbeslissing genomen.</p>
<p>Precies de dag voordat de SEC de wet goedkeurde, stemden leden van het Amerikaanse Huis vóór een wetgeving waarvan velen geloven dat deze meer regelgevende duidelijkheid zal bieden voor de crypto-industrie. De Financial Innovation and Technology Act van de 21e eeuw zal de verantwoordelijkheden van de SEC en de Commodity Futures Trading Commission verduidelijken, maar het moet nog worden aangenomen en door de Senaat tot wet worden ondertekend.</p>
<p>Met de voortdurende vooruitgang van de goedkeuring van spot Ethereum ETF’s, vielen verschillende Bitcoin miners en Bitcoin-gerelateerde aandelen samen met de algemene markt op donderdag. De aandelenkoers van Hut 8 leidde de daling, met een daling van 10%, terwijl concurrenten zoals Riot Platforms en Marathon Digital respectievelijk met ongeveer 7,6% en 5,5% daalden. MicroStrategy daalde met 6,2% vanwege de grote hoeveelheid BTC, die door velen wordt gezien als een vertegenwoordiger van de Bitcoin-prijzen.</p>
<p>De aandelenkoersen van verschillende spot Bitcoin ETF’s zijn met 3% tot 4% gedaald; echter, analist Mark Palmer suggereert dat deze verkopen mogelijk slechts van korte duur zijn.</p>
<p>De analist van Benchmark Stock Research gelooft dat de prijstrend van vandaag een lichte terugval is, “maar we geloven nog steeds dat gunstige vraag- en aanboddynamiek prijsstijgingen in de komende maanden zal ondersteunen.” “In vergelijking met het verleden stemt het goedkeuren van spot Ethereum ETF’s overeen met de meer proactieve regelgevende houding van de Amerikaanse overheid ten aanzien van cryptocurrencies.”</p>
<p><strong>Plume Network heeft $10 miljoen opgehaald aan startkapitaal</strong><br>Plume Network is een modulair layer 2-netwerk dat zich richt op het brengen van real-world assets (RWAs) op de chain. Het bedrijf heeft $10 miljoen aan financiering opgehaald in een seedronde onder leiding van Haun Ventures.</p>
<p>Plume is een modulair, Ethereum Virtual Machine (EVM) compatibel Layer 2-netwerk gericht op RWA. Plume beweert: “Tot nu toe is er geen toestemmingsloze blockchain uitgerust met een volledige RWA-infrastructuur die elk activaklasse in naleving kan implementeren.” Het voegt ook toe dat het platform gebruikers in staat zal stellen om RWA-gerelateerde zaken te doen, zoals winst maken, lenen, handelen en hefboomwerking gebruiken voor speculatie.</p>
<p>Plume bevindt zich momenteel in een privé-testnetwerk en heeft verklaard dat het meer dan 80 RWA- en DeFi-projecten heeft opgezet op zijn netwerk, die collectibles, alternatieve activa, synthetische materialen, luxe goederen, onroerend goed, leen-/leenovereenkomsten en permanente gedecentraliseerde uitwisselingen omvatten.</p>
<p>Plume heeft de afgelopen maanden een privé-testnet uitgevoerd en maakt momenteel de overgang naar de volgende fase. Yin verklaarde dat zijn open stimulans testnetwerk in de komende weken zal worden gelanceerd en het hoofdnetwerk later dit jaar zal worden gelanceerd.</p>
<h2 id="h2-Markttrends20Goedkeuring20van20belangrijke20documenten20voor20ETHspot20ETF20Altcoinseizoen20kan20komen987811"><a name="Markttrends: Goedkeuring van belangrijke documenten voor ETH-spot ETF, Altcoin-seizoen kan komen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Goedkeuring van belangrijke documenten voor ETH-spot ETF, Altcoin-seizoen kan komen</h2><p><strong>BTC en ETH:</strong><br>Gisteravond daalde BTC onder het belangrijke ondersteuningsniveau van $66.500, wat wijst op een kortetermijnzwakte op de markt.<br>ETH steeg kortstondig tot $3.600 en herstelde vervolgens naar $3.900, wat wijst op een hogere volatiliteit. De toename in ETH-volatiliteit is waarschijnlijk het gevolg van marktsentimentschommelingen die werden veroorzaakt door de aankondiging van belangrijke documenten door de SEC voor ETH-spot-ETF’s.</p>
<p><strong>De daling van BTC dominantie:</strong><br>De BTC-heersende koers is met 2% gedaald, wat erop wijst dat geld naar andere crypto-activa stroomt, vooral naar de Altcoin-markt. Dit duidt er meestal op dat Altcoins het op korte termijn beter kunnen doen dan BTC.</p>
<h3 id="h3-Macroeconomische20factoren297524"><a name="Macroeconomische factoren:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomische factoren:</h3><p><strong>De terugtrekking in de Amerikaanse aandelen:</strong><br>De terugval in Amerikaanse aandelen kan een kettingreactie hebben op de cryptomarkt, en investeerders moeten de trends in de traditionele financiële markten in de gaten houden.</p>
<p><strong>PMI-gegevens en verwachte renteverlagingen:</strong><br>De PMI-gegevens zijn gestegen naar een nieuw hoogtepunt in twee jaar, wat wijst op een herstel van de economische activiteit. De verwachte eerste renteverlaging is uitgesteld tot december, wat invloed kan hebben op het risicobereidheid van beleggers.</p>
<h3 id="h3-Markt20Hotspots722250"><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 SEC heeft de goedkeuring aangekondigd van belangrijke documenten voor ETH spot ETF’s, maar het zal nog steeds enkele maanden duren voordat de officiële goedkeuring is verleend. Desalniettemin heeft dit nieuws de marktinteresse en volatiliteit in ETH aanzienlijk verhoogd. Met de vooruitgang van ETF’s kan de marktvraag naar ETH verder toenemen, en beleggers moeten relevante ontwikkelingen nauwlettend in de gaten houden.</p>
<p><strong>ETH-serie prestaties van activa:</strong><br>ENS, ETHFI, MANTA, ETC en andere activa van de ETH-serie zijn gestegen, wat het marktvertrouwen in het ETH-ecosysteem aantoont.</p>
<p>ETHFI heeft de lancering van een herbeleggingscreditcardbedrijf aangekondigd, wat mogelijk de marktwaarde en gebruikersbasis verder kan verbeteren.</p>
<p><strong>Meme concept:</strong><br>Meme concept munten zoals PEOPLE, PEPE en MANEKI blijven stijgen. PEPE heeft de afgelopen dagen een historisch hoogtepunt bereikt en staat momenteel in de top 20 van de hele markt qua marktwaarde.</p>
<p>MANEKI’s amplitude exceeded 30% gisteren, en het projectteam kondigde aan dat de eerste gerangschikte speler van de UFC in de vroege stadia, Merab Dwalishvili, de woordvoerder is geworden voor het project, waardoor de blootstelling en marktaandacht van het project aanzienlijk zijn toegenomen.</p>
<p><strong>RWA sector:</strong><br>De stijging in RWA (Real World Assets) sectoren zoals ONDO, TOKEN en TRU geeft de marktinteresse aan in deze opkomende sector.</p>
<p>De RWA-sector kan verdere integratie vertegenwoordigen tussen de cryptomarkt en de traditionele financiële markten, en investeerders kunnen letten op mogelijke kansen op dit gebied.</p>
<h3 id="h3-Trackanalyse149817"><a name="Trackanalyse:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trackanalyse:</h3><p><strong>Richt je op ETH en zijn ecosysteem op korte termijn:</strong><br>Als gevolg van de impact van ETF-berichten kunnen ETH en de daaraan gerelateerde activa het goed doen.</p>
<p><strong>Volg Meme-conceptmunten:</strong><br>Hoewel de Meme-conceptmunt aanzienlijke schommelingen heeft, kan de hoge exposure en markthitte op korte termijn beleggingskansen bieden.</p>
<p><strong>Let goed op macro-economische gegevens:</strong><br>Veranderingen in PMI-gegevens en verwachte renteverlagingen kunnen een significante invloed hebben op het marktsentiment, en investeerders dienen waakzaam te blijven.</p>
<p><strong>Het potentieel van de RWA-sector:</strong><br>Deze sector heeft mogelijk aanzienlijk groeipotentieel, met name in de context van de integratie van traditionele financiële markten en cryptomarkten.</p>
<p>Over het algemeen bevindt de markt zich momenteel in een fase van hoge volatiliteit en moeten beleggers voorzichtig te werk gaan, met aandacht voor markthoogtepunten en macro-economische veranderingen.</p>
<h2 id="h2-Macro20Sterke20economische20gegevens20maar20bezorgdheid20over20inflatie20zetten20druk20op20de20aandelenprijzen20waardoor20de20wereldwijde20aandelenmarkten20dalen53440"><a name="Macro: Sterke economische gegevens, maar bezorgdheid over inflatie zetten druk op de aandelenprijzen, waardoor de wereldwijde aandelenmarkten dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Sterke economische gegevens, maar bezorgdheid over inflatie zetten druk op de aandelenprijzen, waardoor de wereldwijde aandelenmarkten dalen</h2><p>Op 23 mei meldde Reuters dat ondanks de sterke omzetprognose van Nvidia die de aandelenkoers deed stijgen, de Amerikaanse aandelenmarkt donderdag lager sloot omdat economische gegevens aantoonden dat inflatie nog steeds een zorg is en de renteverlaging van de Federal Reserve kan uitstellen.</p>
<p>De aandelenkoers van Nvidia steeg tegen de trend in en voorspelde een hogere kwartaalomzet dan verwacht, en kondigde een aandelensplitsing aan, waardoor de aandelenkoers met 9,32% steeg aan het begin van de sessie, sloot boven de $1.000 voor de eerste keer, en hielp ook de Nasdaq en de S&amp;P 500 index om een recordhoogte te bereiken in de sessie.</p>
<p>Echter, wat betreft specifieke indices, daalde de Dow Jones-index met 1,53%, daalde de S&amp;P-index met 0,74%, en daalde de Nasdaq-index met 0,39%. Hoewel de stijging van Nvidia de S&amp;P 500 Technology Index met 0,56% omhoog dreef, waardoor het de enige sector was die steeg, daalden over het algemeen de aandelen van chipbedrijven, met de Philadelphia Semiconductor Index lichtjes 0,02% lager.</p>
<p>De gegevens die donderdag door de Verenigde Staten zijn vrijgegeven, tonen een daling van het aantal eerste werkloosheidsuitkeringen, terwijl de voorlopige enquête van Standard &amp; Poor’s Global PMI laat zien dat de bedrijvigheid in mei sneller groeide dan economen hadden voorspeld.</p>
<p>Sterke economische gegevens en havikachtige notulen van de laatste bijeenkomst van de Federal Reserve eerder deze week hebben handelaren ertoe aangezet hun weddenschappen op een renteverlaging dit jaar te verminderen. De markt verwacht dat de Federal Reserve de rente in 2024 slechts met 35 basispunten zal verlagen, in vergelijking met de verwachting van een verlaging met 150 basispunten aan het begin van het jaar.</p>
<p>Op 24 mei daalden de Aziatische aandelenmarkten op vrijdag en steeg de Amerikaanse dollar als gevolg van sterke Amerikaanse economische gegevens, waardoor de kans op het handhaven van hogere rentetarieven werd vergroot. De Federal Reserve heeft mogelijk geen haast om de rente te verlagen, waardoor beleggers wegblijven van risicovolle activa.</p>
<p>De MSCI Asia Pacific Stock Index daalde met 0,5% en kan deze week met 1% dalen, waarmee vier opeenvolgende weken van opwaartse momentum worden beëindigd. De Chinese aandelenmarkt bleef grotendeels onveranderd in de vroege handelssessie, waarbij blue-chip aandelen met 0,05% daalden. De Hang Seng Index in Hong Kong daalde met 0,33%. De Nikkei-index in Japan daalde met 1,45%.</p>
<p>De Amerikaanse dollar index steeg bijna tot 105,06 deze week, naar verwachting zal het zijn grootste wekelijkse stijging sinds medio april registreren. De stijging van de Amerikaanse dollar blijft druk uitoefenen op de Japanse yen. De laatste wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar was 157,03, wat niet ver verwijderd is van de drie weken durende laagte van 157,19 die op donderdag werd bereikt.</p>
<p>Volgens gegevens die vrijdag door de overheid zijn vrijgegeven, is de kerninflatie in Japan in april voor de tweede opeenvolgende maand afgenomen als gevolg van een daling van de voedselinflatie, maar blijft deze nog steeds op het streefniveau van 2% van de centrale bank.</p>
<p>Wat betreft grondstoffen blijven de olieprijzen stabiel, met Brent ruwe olie futures geprijsd op $81,39 per vat, terwijl West Texas Intermediate (WTI) ruwe olie futures in de Verenigde Staten geprijsd zijn op $76,87 per vat.</p>
<p>De goudprijs steeg met 0,24% tot $2.334,16 per ounce, maar is met 3,3% gedaald voor de week sinds het einde van september.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>