RGFnZWxpamtzIG5pZXV3cyB8IEVUSCBoZXJzdGVsZGUgemljaCwgTWVtZSB2ZXJzdGVya3Q7IExhbmNlcmluZyB2YW4gU3BvdCBFVEggRVRGJ3Mgd2VyZCB2ZXJ0cmFhZ2QgdmFud2VnZSBvcG1lcmtpbmdlbiB2YW4gZGUgU0VDOyAyMSBhYW5kZWxlbiBoZWJiZW4gZWVuIFMtMS1iZXN0YW5kIGluZ2VkaWVuZCB2b29yIFNwb3QgU09MIEV

2024-07-01, 04:10

<p><img src="https://gimg2.gateimg.com/image/article/17198068411_2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20lancering20van20spot20Ethereum20ETFs20is20vertraagd20vanwege20opmerkingen20van20de20SEC202120Shares20heeft20een20S120bestand20ingediend20voor20spot20Solana20ETF20Roaring20Kitty20werd20geconfronteerd20met20beschuldigingen20van20effectenfraude20in20GMEgerelateerde20rechtszaken458965"><a name="Crypto Dagelijkse Samenvatting: De lancering van spot Ethereum ETF’s is vertraagd vanwege opmerkingen van de SEC; 21 Shares heeft een S-1 bestand ingediend voor spot Solana ETF; Roaring Kitty werd geconfronteerd met beschuldigingen van effectenfraude in GME-gerelateerde rechtszaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De lancering van spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s is vertraagd vanwege opmerkingen van de SEC; 21 Shares heeft een S-1 bestand ingediend voor spot <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ETF; Roaring Kitty werd geconfronteerd met beschuldigingen van effectenfraude in GME-gerelateerde rechtszaken</h2><p>Allereerst gaan we 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 ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 28 juni uitstroom van $27.2 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een uitstroom van $25 miljoen, iShares Trust Bitwise Bitcoin spot ETF (IBIT) had een instroom van $84.1 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $42.8 miljoen.</p>
<p><strong>De lancering van spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF is vertraagd vanwege opmerkingen van de SEC</strong><br>De Amerikaanse Securities and Exchange Commission (SEC) heeft gereageerd op het S-1 formulier en heeft om een herindiening gevraagd vóór 8 juli, wat de lancering van de spot Ethereum ETF vertraagd heeft tot medio tot eind juli. Hoewel veel mensen verwachtten dat Ethereum ETF’s al op 2 juli zouden worden gelanceerd, heeft de SEC dit plan uitgesteld.</p>
<p>ETF-analist Eric Balchunas zei dat deze nieuwe planning betekent dat de spot Ethereum ETF mogelijk in het midden tot eind juli wordt gelanceerd. Nate Geraci, voorzitter van ETF Store, wees erop dat de vorige ronde van S-1-wijzigingen relatief klein was en dat naar verwachting de SEC binnen 14 tot 21 dagen goedkeuring zal verlenen aan uitgevers voor de handel. Hoewel de exacte tijdslijn nog onzeker is, heeft de SEC aangegeven dat deze mogelijk deze zomer wordt gelanceerd.</p>
<p>De goedkeuring van het S-1 formulier is het tweede deel van het tweestapsproces dat vereist is voor de notering van ETF’s. Het eerste deel omvat de goedkeuring van de 19b-4 formulieren die in mei zijn ingediend door de emittent. Op 23 mei heeft de SEC de 19b-4 formulieren goedgekeurd voor acht ETF bieders.</p>
<p><strong>21 Shares heeft het S-1-bestand ingediend voor spot <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETF</strong><br>Beleggingsmaatschappij 21Shares heeft het S-1 formulier voor Solana ETF ingediend bij de Amerikaanse Securities and Exchange Commission, en haar concurrent VanEck heeft op dezelfde dag ook een soortgelijk document ingediend. Dit is de tweede keer dat de Verenigde Staten binnen enkele dagen een SOL ETF-aanvraag heeft ingediend, wat ook enkele voorspellingen van analisten bevestigt dat de aanvraag van VanEck die op 27 juni is ingediend, de deur zal openen voor concurrenten die Solana-gebaseerde fondsen willen lanceren.</p>
<p>21 Shares, gevestigd in Zürich, Zwitserland, beheert een fysiek ondersteund Solana Staking exchange-traded product met een beheerd vermogen van meer dan $846 miljoen. Het beheert ook een Bitcoin ETF die is gelanceerd voor de handel.</p>
<p>“21 Shares is enthousiast over de mogelijkheid van een ETF die toetreedt tot het Solana-ecosysteem in de Verenigde Staten”, zei Andrew Jacobson, juridisch directeur van 21 Shares. “We geloven dat dit een noodzakelijke stap is voor de crypto-industrie en in lijn is met onze missie om gemakkelijk toegankelijke financiële producten te lanceren rondom crypto-activa.” Op het moment van publicatie was de handelsprijs van SOL $147.58.</p>
<p>De onderzoeksdirecteur van VanEck is van mening dat Ethereum binnenkort zijn reeks ETF’s zal lanceren en dat dit nu het beste moment is om SOL ETF’s goed te keuren. Vanuit praktisch oogpunt kan het echter moeilijker zijn voor SOL ETF’s om het SEC-beoordelingsproces te doorstaan.</p>
<p><strong>Roaring Kitty werd geconfronteerd met beschuldigingen van effectenfraude in GME-gerelateerde rechtszaken
</strong><br>Keith Gill, een aandelenhandelaar die bekend staat om de short squeeze op GameStop in 2021, heeft beschuldigingen van effectenfraude geconfronteerd vanwege een reeks recente berichten op sociale media die leidden tot aanzienlijke schommelingen in de GameStop (GME) aandelenkoersen van mei tot juni.</p>
<p>De rechtszaak werd op 28 juni aangespannen in het Eastern District of New York, met als doel Gill aan te klagen wegens het plannen van een ‘Pump and Dump’-plan via een reeks socialemediaberichten vanaf 13 mei. In de aanklacht wordt beweerd dat Gill schuldig is aan effectenfraude en niet volledig de aankoop en verkoop van zijn GameStop-opties heeft bekendgemaakt, wat vermoedelijk zijn volgers heeft misleid en verliezen heeft veroorzaakt voor sommige investeerders.</p>
<p>De eiser Martin Radev, vertegenwoordigd door het advocatenkantoor Pomerantz, verklaarde dat hij sinds half mei in totaal 25 GME-aandelen en 3 call-opties heeft gekocht en schade heeft geleden door de zogenaamde ‘Pump and Dump’.</p>
<p>Eerder beëindigde Gill twee jaar van sociale media stilte door een reeks mysterieuze emoji’s op zijn X-account te plaatsen, waardoor de aandelenkoers van GameStop met 180% steeg. Op 14 mei steeg de aandelenkoers van $17,46 naar $48,75. Op 13 juni verklaarde Gill dat hij alle 120.000 opties had uitgeoefend, waarmee hij miljoenen dollars verdiende, en deze winsten gebruikte om zijn belang in GameStop-aandelen verder te vergroten.</p>
<h2 id="h2-Markttrends20Goedkeuring20van20de20EthereumspotETF20is20aanstaande20met20een20sterke20rebound20op20de20markt293884"><a name="Markttrends: Goedkeuring van de Ethereum-spot-ETF is aanstaande, met een sterke rebound op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Goedkeuring van de Ethereum-spot-ETF is aanstaande, met een sterke rebound op de markt</h2><p>BTC brak vanochtend door de $63.500, een belangrijke psychologische en technische hindernis. De sterke prestaties van Bitcoin drijven meestal de hele cryptomarkt omhoog. Qua technische analyse, als we standvastig blijven op het niveau van $63.500, kan het volgende doel $65.000 of zelfs hoger zijn.</p>
<p>ETH brak vanochtend ook door de $3.500 grens. De sterke prestatie van Ethereum is niet alleen te danken aan zijn positie als op één na grootste cryptocurrency wat betreft marktwaarde, maar ook aan de voortdurende uitbreiding van zijn ecosysteem en toenemende toepassingen. $3.500 is een belangrijk weerstandsniveau, en als het kan doorbreken en stabiliseren, kan het verder stijgen naar $3.700 of zelfs $4.000.</p>
<p>Altcoins herstellen doorgaans mee met de algehele markt, vooral bij de sterke prestaties van Bitcoin en Ethereum. Altcoins hebben meestal een grotere volatiliteit en opwaarts potentieel. Dit komt doordat fondsen zullen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in kleinere tokens op de markt, op zoek naar hogere rendementen.</p>
<h3 id="h3-Macroeconomie317904"><a name="Macroeconomie:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie:</h3><p>Daling van de Amerikaanse aandelenmarkt: Hoewel de vrijdag vrijgegeven PCE-gegevens in lijn waren met de verwachtingen, heeft de markt de CPI- en PPI-gegevens al van tevoren verwerkt en hebben de PCE-gegevens het op- en neerwaartse marktpatroon van de Amerikaanse aandelenmarkt niet veranderd. De prestaties van de Amerikaanse aandelenmarkt hebben een zekere invloed op de cryptomarkt, maar momenteel wordt de onafhankelijkheid van de cryptomarkt sterker.</p>
<h3 id="h3-Markt20Hotspots498483"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>ETH Ecosysteem:</strong><br>ENS en SSV: Met de sterke opleving van ETH zijn deze Ethereum ecosysteemprojecten met meer dan 20% gestegen. ENS (Ethereum Domain Name Service) en SSV (Staking Protocol) zijn belangrijke onderdelen van het Ethereum ecosysteem en weerspiegelen het marktvertrouwen in de goedkeuring van Ethereum spot ETF’s.</p>
<p>SEC klaagt Consensys aan: De Amerikaanse SEC heeft de rechtszaak aangekondigd tegen het ontwikkelingsteam van Metamak, Consensys, en verklaarde dat stakingprojecten zoals LDO en RPL als effecten worden beschouwd. Dit kan op korte termijn een negatieve invloed hebben op deze projecten.</p>
<p><strong>Meme Sector:</strong><br>Meme-munten op de Solana-keten, zoals MOTHER en POPCAT, zijn met meer dan 30% gestegen. Vanwege hun snelle en goedkope handelskenmerken hebben Meme-munten op de Solana-keten een grote hoeveelheid speculatief kapitaal aangetrokken.</p>
<p>Ethereum on-chain politieke Meme munten: MAGA steeg met meer dan 25%. Politieke Meme munten zijn gevoelig voor aanzienlijke schommelingen die worden gedreven door specifieke gebeurtenissen of nieuws.</p>
<p>Meme munten van het kattentype: MOG is teruggekeerd naar het $0.000002 niveau, nog maar één stap verwijderd van het nieuwe hoogtepunt.</p>
<p><strong>Token Ontgrendelen:</strong><br>Toonaangevende token WLD in AI-sector: Vanaf 24 juli zal WLD dagelijks bijna $20 miljoen aan tokens ontgrendelen gedurende een periode van twee jaar. Voortdurende ontgrendeling van tokens zal verkoopdruk op de markt brengen, en investeerders moeten voorzichtig zijn, vooral gericht op prijsschommelingen tijdens de ontgrendelingsperiode.</p>
<p>De algehele prestaties van de huidige markt zijn sterk, vooral de doorbraken in Bitcoin en Ethereum, die het vertrouwen in de hele markt hebben vergroot. Investeerders moeten echter nog steeds macro-economische gegevens en regelgevingsdynamiek in de gaten houden, die op korte termijn invloed kunnen hebben op de markt. Bij het kiezen van investeringsdoelen moeten investeerders zich richten op hoogwaardige projecten binnen de Solana- en Ethereum-ecoen, terwijl ze voorzichtig zijn met risicovolle Meme-munten en tokens die binnenkort te maken krijgen met een grote hoeveelheid ontgrendeling en verkoopdruk.</p>
<h2 id="h2-Macro20Markt20verwerkt20inflatiedata20Wall20Streetindex20daalt20Aziatische20markt20opent20traag254476"><a name="Macro: Markt verwerkt inflatiedata, Wall Street-index daalt; Aziatische markt opent traag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Markt verwerkt inflatiedata, Wall Street-index daalt; Aziatische markt opent traag</h2><p>Op vrijdag 28 juni, terwijl investeerders verwachte inflatiedata verwerkten en de politieke onzekerheid na het debat van de Amerikaanse president overwogen, zwakten de vroege winsten op de Amerikaanse aandelenmarkt geleidelijk af en sloten vrijdag lager.</p>
<p>De prestaties van de index zijn als volgt: de Dow Jones-index daalde met 0,11%, de Standard &amp; Poor’s-index daalde met 0,41% en de Nasdaq-index daalde met 0,71%. In de S&amp;P 500-index presteerden de energiesector en de vastgoedsector het beste, met respectievelijk een stijging van 0,42% en 0,62%; Aandelen van nutsbedrijven en communicatiediensten daalden respectievelijk met 1,08% en 1,63%.</p>
<p>De gegevens tonen aan dat het maandelijkse inflatiepercentage in de Verenigde Staten in mei onveranderd is gebleven, wat een bemoedigende vooruitgang is na sterke prijsstijgingen eerder dit jaar die twijfels opriepen over de effectiviteit van het monetaire beleid van de Federal Reserve. Het rapport van het Ministerie van Handel toont ook aan dat de consumentenbestedingen vorige maand licht zijn gestegen, wat het vertrouwen van de mensen versterkt. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de Amerikaanse centrale bank die een ‘zachte landing’ in de economie bereikt.</p>
<p>Volgens de gegevens van Federal Watch van de London Stock Exchange verwacht de markt dat de kans op een renteverlaging in september stijgt tot 66% na de publicatie van de Persoonlijke Consumenten Uitgavenprijsindex. Hoewel de Federal Reserve voorspelt dat het dit jaar slechts één keer de rente zal verlagen, wedden handelaren nog steeds op twee renteverlagingen, in de verwachting dat de inflatie zal blijven afkoelen.</p>
<p>Op maandag 1 juli opende de Aziatische markt een nieuwe week, kwartaal en halfjaar van handel, waarbij investeerders zich richtten op de data-intensieve economische kalender.</p>
<p>Over het algemeen presteerden Aziatische aandelenmarkten zwak op maandag, aangezien handelaren zich richtten op het vooruitzicht van de Amerikaanse rentetarieven. Tegelijkertijd steeg de euro, aangezien bij de eerste ronde van vroege verkiezingen in Frankrijk rechtse partijen wonnen ondanks een lagere opkomst dan sommige opiniepeilingen hadden voorspeld. De euro steeg met 0,32%, Europese aandelentermijncontracten stegen met 1% en Franse OAT-obligatietermijncontracten stegen met 0,15%, aangezien beleggers beter-dan-verwachte resultaten verwerkten, hoewel er nog steeds onzekerheid bestaat.</p>
<p>Het rapport van de inkoopmanagersindex van Caixin Manufacturing in juni zal de huidige situatie in China weerspiegelen. Beleggers hopen op sterke groei, maar de resultaten tonen een ongelijke economische groei, aanhoudende deflatoire risico’s en enorme druk op de aandelenmarkt en wisselkoers, waardoor meer stimuleringsmaatregelen nodig zijn.</p>
<p>De inkoopmanagersindex (PMI) voor de productiesector, die zondag werd vrijgegeven door het Nationaal Bureau voor de Statistiek van China, was 49,5, onveranderd ten opzichte van mei. Dit markeert de tweede opeenvolgende maand van afname in de productieactiviteit. De PMI voor de dienstensector daalde naar 50,2, een nieuw dieptepunt van 5 maanden, terwijl de PMI voor de bouwsector daalde naar 52,3, het laagste niveau sinds juli vorig jaar. Deze gegevens duiden allemaal op economische groei, zij het in een langzamer tempo.</p>
<p>De inkoopmanagersindex voor verschillende andere Aziatische landen, waaronder Japan, India, Zuid-Korea en Australië, wordt maandag uitgebracht.</p>
<p>De MSCI Asia Pacific Stock Index steeg met 0,07%, terwijl de Nikkei Index in Japan met 0,57% steeg. De Chinese aandelenmarkt daalde, waarbij blue-chip aandelen met 0,45% daalden. De Hang Seng Index in Hong Kong bleef onveranderd.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gestegen, waarbij de Brent futures met 0,39% stegen tot $85,33 per vat en de West Texas Intermediate ruwe olie futures in de Verenigde Staten met 0,42% stegen tot $81,88 per vat.</p>
<p>Spotgoud steeg met 0,1% tot $2.327,12 per ounce. De goudprijzen stegen met meer dan 4% in het tweede kwartaal. Amerikaanse goudtermijnen daalden met 0,1% tot $2.336,60.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>