RGFnZWxpamtzIG5pZXV3cyB8IEdhbWVGaSBTZWN0b3IgbGVpZGRlIGRlIG1hcmt0OyBSb2FyaW5nIEtpdHR5IG9udGh1bGRlIDE4MCBtaWxqb2VuIEdNRS1hYW5kZWxlbjsgU29sYW5hIGhlZWZ0IGJpam5hIDUwMEsgdG9rZW5zIHVpdGdlZ2V2ZW4gaW4gbWVp

2024-06-04, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/17174723191_3.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Roaring20Kitty20onthulde2018020miljoen20aan20GMEaandelen20en20GameStop20steeg20s20nachts20Blast20heeft20de20blobconversie20voltooid20en20rekent20een20lagere20vergoeding20Het20Solana20Network20heeft20in20mei20bijna2050000020tokens20uitgegeven170008"><a name="Crypto Dagelijkse Samenvatting: Roaring Kitty onthulde $180 miljoen aan GME-aandelen en GameStop steeg ‘s nachts; Blast heeft de blobconversie voltooid en rekent een lagere vergoeding; Het Solana Network heeft in mei bijna 500.000 tokens uitgegeven." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Roaring Kitty onthulde $180 miljoen aan GME-aandelen en GameStop steeg ‘s nachts; Blast heeft de blobconversie voltooid en rekent een lagere vergoeding; Het <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Network heeft in mei bijna 500.000 tokens uitgegeven.</h2><p>Allereerst, laten we het onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteiten van ETF’s. Volgens Farside Investor-gegevens ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 3 juni nog steeds uitstroom van $276,2 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $77 miljoen, Bitwise Bitcoin spot ETF (BITB) had een instroom van $14,3 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $10,7 miljoen en WisdomTree Bitcoin spot ETF (BTCW) had een nettostroom van $1,1 miljoen.</p>
<p><strong>Roaring Kitty onthulde $ 180 miljoen aan GME-bezit, GameStop steeg ‘s nachts</strong><br>Keith Gill, bekend als ‘Roaring Kitty’ op Reddit, plaatste dat na het vasthouden van GameStop-aandelen (GME) en call-opties ter waarde van $181,4 miljoen, de aandelenkoers van GameStop met meer dan 19% steeg tijdens de nachtelijke handel.</p>
<p>Gill is een handelaar die een belangrijke rol speelde in de 2021 GME short squeeze. Hij plaatste zijn eerste bericht op zijn Reddit-account op 2 juni sinds april 2021. In dit bericht deelde hij een screenshot waarin te zien is dat hij 5 miljoen aandelen GME heeft gekocht voor $115,7 miljoen en $65,7 miljoen heeft geïnvesteerd in call-opties, waarbij hij wedde dat de GME-aandelenprijs op 21 juni ten minste $20 per aandeel zou bereiken.</p>
<p>Nadat Gill had gepost, liet de overnight markt van Robinhood zien dat de GME-aandelenprijs met 19,19% steeg tot $27,58 binnen 20 minuten. Eerder, in 2021, werd Gill beschouwd als een van de belangrijke figuren in de legende van GameStop, en Reddit-handelaren slaagden erin de verwachtingen van hedgefondsen succesvol omver te werpen door de worstelende fysieke game winkel short te verkopen.</p>
<p>Sommige mensen geloven ook dat de bearish squeeze op GameStop de basis heeft gelegd voor een aanzienlijke stijging van memecoins zoals <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a>. Naarmate particuliere beleggers hun aandacht verleggen, is de prijs van memecoins ook dienovereenkomstig gestegen.</p>
<p><strong>Blast heeft de conversie van blobs voltooid en lagere kosten in rekening gebracht</strong><br>Het Blast-netwerk heeft vorige week de conversie van calldata naar blob voltooid, waardoor lagere kosten worden bereikt.</p>
<p>Blast is een relatief nieuwe Optimistic Rollup die aanvankelijk de aandacht trok vanwege zijn ondersteuning voor inheemse inkomsten. De vroege toegang begon in november 2023, waardoor gebruikers konden storten maar niet opnemen. Het platform verzamelde natuurlijk meer dan $1 miljard aan TVL door de verdiende Blast Points-brug. Ondanks kritiek dat de beloningsstructuur voor uitnodigingen lijkt op een Ponzi-schema, is Blast nu opengesteld voor het publiek.</p>
<p>Hoewel het nog niet is airdropped, trekt Blast nog steeds de aandacht van het publiek omdat het de steun heeft van Paradigm, opgericht door de oprichter van Blur op de NFT-markt, en het biedt inkomstmogelijkheden.</p>
<p>Bovendien is Blast ook de locatie van het crypto protocol fantasy.top, waarmee gebruikers de handelskaarten van crypto influencers kunnen verhandelen. Aan het begin van deze maand stond het platform in de top tien qua dagelijkse kosten, ondanks een vertraging in de omzet.</p>
<p>Op het gebied van activiteit loopt Blast nog steeds achter op Arbitrum. Toen het werd gelanceerd, beleefde Base zijn tweede golf van populariteit, dus Blast viel achter bij de Optimistic Rollup ondersteund door Coinbase. De dagelijkse handelsvolume is meestal consistent met <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, met ongeveer 500.000 transacties per dag, wat nog steeds behoorlijk indrukwekkend is voor een relatief nieuw netwerk.</p>
<p>Ongeacht het gebruik kunnen alle Layer 2-netwerken die beginnen met het gebruik van Blob in plaats van Calldata om transactiesamenvattingen te publiceren, profiteren omdat deze methode een goedkopere manier biedt om gegevens op te slaan. Sinds de Blob-upgrade op 27 mei is de gemiddelde transactiekosten van Blast onder de $0,01 gebleven, waardoor het een van de goedkoopste Layer 2 is.</p>
<p><strong><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> gaf in mei bijna 500.000 tokens uit, voornamelijk memecoin</strong><br>Vanwege de lage drempel en de sterke vraag naar het creëren van populaire meme-munten, werden er in mei bijna 500.000 tokens uitgegeven op het Solana-platform.</p>
<p>De meeste tokens op Solana zijn meme-munten, die snel de aandacht trokken van cryptoliefhebbers. Deze trend versterkt zich met de snelle opkomst van sommige op Solana gebaseerde mememunten (zoals Dogwifhat, Bonk en Book of Meme) in de ranglijsten van de cryptomarkt.</p>
<p>Een deel van het succes wordt toegeschreven aan Pump.fun, een platform dat het voor iedereen gemakkelijker maakt om tokens uit te geven en de uitgifte van meer tokens stimuleert. Solana heeft tot nu toe dit jaar 1,1 miljoen nieuwe tokens uitgegeven. Pump.fun is het lanceerplatform voor politieke memecoins zoals Jeo Boden en Doland Tremp, die voorafgaand aan de aankomende Amerikaanse verkiezingen groot succes hebben behaald.</p>
<p>Het aantal nieuw gecreëerde tokens is een indicator van het crypto-ecosysteem en weerspiegelt meer over de betaalbaarheid en hoge doorvoer van de keten. Het houdt echter geen rekening met de waarde die door elke token wordt opgebouwd en is ook een ijdele indicator, omdat de meeste tokens geen liquiditeit hebben en snel worden vergeten.</p>
<h2 id="h2-Markttrends20de20GameFisector20leidde20de20markt20wat20het20risico20op20een20kortetermijndaling20van20de20markt20vergrootte524329"><a name="Markttrends: de GameFi-sector leidde de markt, wat het risico op een kortetermijndaling van de markt vergrootte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de GameFi-sector leidde de markt, wat het risico op een kortetermijndaling van de markt vergrootte</h2><p><strong>BTC en ETH Trends</strong><br>Na gisteren door de $70.000 te zijn gebroken, daalde BTC terug naar ongeveer $69.000, wat wijst op een zekere mate van verkoopdruk en winstneming. Gebruikers moeten de steun en weerstand van $70.000 in de gaten houden als een belangrijke psychologische barrière.</p>
<p>ETH consolideerde rond de $3.770, met een relatief stabiele prestatie op korte termijn. U kunt letten op of het boven de $3.800 kan stabiliseren om de volgende trend te bepalen.</p>
<p><strong>Macroeconomische omgeving</strong><br>Volatiliteit op de Amerikaanse aandelenmarkt: De technische storing van de New York Stock Exchange heeft ervoor gezorgd dat verschillende aandelen bijna terugvallen naar nul, wat wijst op de kwetsbaarheid en onzekerheid van de markt. In de onstabiele traditionele financiële markt kan de cryptomarkt een veilige haven worden voor fondsen, maar het is ook noodzakelijk om voorzichtig te zijn met de algehele toename van de marktvolatiliteit.</p>
<p>De scherpe daling van de Amerikaanse dollarindex kan activa die in Amerikaanse dollars luiden (inclusief cryptocurrencies) relatief aantrekkelijker maken.</p>
<h3 id="h3-Markt20hotspots937275"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p><strong>GameFi Sector</strong><br>ALICE, PYR, GHST, DAR, SLP, VOXEL en andere tokens zijn gestegen, wat het enthousiasme van investeerders voor GameFi aantoont. Vanwege de relatief kleine marktwaarde van deze tokens, kan er op korte termijn ruimte zijn voor verbetering vanwege de lage weerstand tegen trekkracht.</p>
<p>Strategie: Gebruikers kunnen overwegen om deze tokens op korte termijn vast te houden, maar wees op uw hoede voor het risico van een terugval na een snelle stijging.</p>
<p><strong>Concept van Algoritmische Stablecoins</strong><br>ENA en SPELL zijn gestegen: de uitgifte van USDe door ENA bereikte een schaal van $3 miljard, wat wijst op een toename van de marktvraag naar algoritmische Stablecoins.</p>
<p>Strategie: Gebruikers kunnen de ecologische ontwikkeling en toepassingsscenario’s van tokens volgen en tokens kiezen met praktische toepassingsvooruitzichten voor investeringen op middellange en lange termijn.</p>
<p><strong>BTC Ecosysteem</strong><br>Rune DOG steeg: DOG bleef stijgen naar een historisch hoogtepunt, met een marktkapitalisatie van bijna $900 miljoen, waarmee het de inieleider ORDI overtrof.</p>
<p>Strategie: Overweeg om gedeeltelijke winst te nemen wanneer de markt heet is, terwijl je let op veranderingen in marktsentiment.</p>
<p><strong>Meme Tokens op Solana Chain</strong><br>GME, PONKE, POPCAT en anderen stegen scherp: Om 4 uur vanochtend publiceerde Roaring Kitty een screenshot van haar positie in de Superstone-sector van Reddit. Haar GME call-opties veranderden verliezen in winst, met een winst van $51,83 miljoen.</p>
<p>Strategie: Deze Meme-tokens hebben een hoge volatiliteit en zijn geschikt voor investeerders met een hoog risico. We moeten veranderingen in marktsentiment nauwlettend volgen en prompt winst en verlies stoppen.</p>
<p>De huidige markt zit vol met kansen en risico’s, en investeerders moeten flexibele aanpassingen maken op basis van hun eigen risicotolerantie en marktdynamiek. Op korte termijn kunnen GameFi, het concept van algoritmische Stablecoins en sommige populaire tokens het goed doen, maar het is noodzakelijk om waakzaam te zijn voor snelle veranderingen in marktsentiment en tijdig risicobeheer uit te voeren.</p>
<h2 id="h2-Macro20Productiedata20en20schommelingen20op20de20New20York20Stock20Exchange20hadden20een20lichte20impact20met20Wall20Street20die20hoger20sloot20en20Aziatische20markten20die20daalden20juni20zal20belangrijke20verkiezingsresultaten20laten20zien20in20meerdere20regios897129"><a name="Macro: Productiedata en schommelingen op de New York Stock Exchange hadden een lichte impact, met Wall Street die hoger sloot en Aziatische markten die daalden; juni zal belangrijke verkiezingsresultaten laten zien in meerdere regio’s." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Productiedata en schommelingen op de New York Stock Exchange hadden een lichte impact, met Wall Street die hoger sloot en Aziatische markten die daalden; juni zal belangrijke verkiezingsresultaten laten zien in meerdere regio’s.</h2><p>Op maandag 3 juni, als gevolg van zwakke productiegegevens en de storing van de New York Stock Exchange, werden tientallen aandelen tijdelijk opgeschort. De S&amp;P 500-index en de Nasdaq-index stegen licht in volatiele handel op maandag.</p>
<p>De stijging en daling van de belangrijkste indices varieerde: de Dow Jones Industrial Average daalde met 0,30%, de S&amp;P 500 Index steeg met 0,11% en de Nasdaq Index steeg met 0,56%.</p>
<p>De storing van de New York Stock Exchange resulteerde in aanzienlijke schommelingen in de aandelenkoersen van Berkshire Hathaway (BRKa.N) en Barrick Gold. Vanwege de volatiliteit werden ten minste 60 aandelen genoteerd aan de New York Stock Exchange opgeschort van de handel. De beurs heeft vervolgens de technische problemen verholpen en de handel hervat.</p>
<p>Volgens de FedWatch-tool van de Chicago Mercantile Exchange voorspellen handelaren een kans van 59% dat de Federal Reserve de rente in september zal verlagen, hoger dan de 53% voor de publicatie van de ISM-gegevens. Zwakke productiegegevens hebben het rendement op de benchmark 10-jaars schatkistpapier naar een twee weken durend laagterecord geduwd.</p>
<p>Begin juni zal de wereld een reeks belangrijke verkiezingsresultaten verwelkomen, waarbij populaire kandidaten uit Mexico en India overweldigend winnen. Ondertussen heeft de Amerikaanse arbeidsmarkt een cruciale week ingeluid, waarbij de aandelenmarkten van Wall Street een actieve prestatie laten zien. Bij de Mexicaanse presidentsverkiezing won Claudia Sheinbaum, waardoor de peso tot een vijf weken laag daalde voor de opening van maandag.</p>
<p>Op 4 juni daalden de Aziatische aandelenmarkten lichtjes op dinsdag, omdat mondiale investeerders geloven dat het ‘uitzonderlijke’ vooruitzicht voor de Amerikaanse economie begon te vervagen naarmate de productieactiviteit in ‘s werelds grootste economie verder verzwakte.</p>
<p>De MSCI Asia Pacific aandelenindex daalde met 0,1% na een lichte stijging op de vorige handelsdag en is tot nu toe deze maand met 1,6% gestegen. Australische aandelen daalden met 0,21%, terwijl de Nikkei-index van Japan met 0,77% daalde. De Hang Seng Index in Hong Kong bleef ongewijzigd in de vroege handelssessie, terwijl de CSI 300 Index in China met 0,16% daalde.</p>
<p>Het rendement op Amerikaanse schatkistobligaties met een looptijd van 10 jaar bereikte 4,4001%, terwijl de VS maandag sloot op 4,402%. Het rendement van schatkistobligaties met een looptijd van twee jaar bereikte 4,8184%, aangezien handelaren verwachtten dat de federale fondsrente zou stijgen, ten opzichte van de Amerikaanse slotkoers van 4,818% op maandag.</p>
<p>Na het verzamelen van 642 miljoen stemmen in ‘s werelds grootste verkiezing in India, wordt verwacht dat premier Narendra Modi voor de derde opeenvolgende keer wordt gekozen. Analisten zeggen dat dit resultaat naar verwachting een positieve invloed zal hebben op de Indiase financiële markt en verdere economische hervormingen in India zal stimuleren.</p>
<p>Op de valutamarkt steeg de Amerikaanse dollar met 0,16% tegenover de Japanse yen tot 156,35, maar het is nog steeds ver verwijderd van het jaarlijkse hoogtepunt van 160,03 dat eind april werd bereikt. De euro steeg met 0,1% tegenover de Amerikaanse dollar tot $1,0912, wat neerkomt op een stijging van 0,65% binnen een maand. De Amerikaanse dollarindex die de wisselkoers van de Amerikaanse dollar bijhoudt ten opzichte van een mandje met andere belangrijke handelspartners daalde naar 104.</p>
<p>Wat betreft grondstoffen daalde de prijs van Amerikaanse ruwe olie met 0,42% naar $73,91 per vat. Brent ruwe olie daalde naar $78,05 per vat. Na de overeenkomst van OPEC+ om enkele productieverlagingen vanaf oktober te annuleren, daalden beide referentieprijzen voor ruwe olie naar het laagste niveau in vier maanden op maandag.</p>
<p>Goud steeg licht, met spotgoud dat wordt verhandeld op $2.350,73 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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>