RGFnZWxpamtzIG5pZXV3cyB8IFRlY2hub2xvZ2llYmV1cnNjcmFzaCB2ZXJvb3J6YWFrdCBtYXJrdHNjaG9tbWVsaW5nZW47IENyeXB0byBtYXJrdCBpcyBvdmVyIGhldCBhbGdlbWVlbiBsYWdlciwgbWFhciBNRVcsIFdJRiBlbiBTb2xhbmEgTWVtZWNvaW5zIHN0aWpnZW47IE1vbm9Td2FwIGlzIGdlaGFja3Qu

2024-07-25, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/17218778221_20.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20cryptomarkt20is20over20het20algemeen20gedaald20maar20MEW20WIF20en20Solana20Memecoins20stijgen20MonoSwap20is20gehackt20en20gebruikers20zijn20gewaarschuwd20om20geen20geld20te20storten20Fold20is20van20plan20genoteerd20te20worden20aan20NASDAQ20via20een20SPACtransactie20van2036520miljoen464131"><a name="Crypto Dagelijkse Samenvatting: De cryptomarkt is over het algemeen gedaald, maar MEW, WIF en Solana Memecoins stijgen; MonoSwap is gehackt en gebruikers zijn gewaarschuwd om geen geld te storten; Fold is van plan genoteerd te worden aan NASDAQ via een SPAC-transactie van $365 miljoen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De cryptomarkt is over het algemeen gedaald, maar MEW, WIF en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Memecoins stijgen; MonoSwap is gehackt en gebruikers zijn gewaarschuwd om geen geld te storten; Fold is van plan genoteerd te worden aan NASDAQ via een SPAC-transactie van $365 miljoen.</h2><p>Laten we eerst de handelsactiviteit van nader bekijken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s. Volgens gegevens van Farside Investor had de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 24 juli een fondsafvloeiing van $26,2 miljoen. Ondertussen ontving de Fidelity Bitcoin Spot ETF (FBTC) een instroom van $1,4 miljoen, ontving de Bitwise Bitcoin Spot ETF (BITB) een afvloeiing van $70,3 miljoen en ontving de ARK 21Shares Bitcoin Spot ETF (ARKB) een afvloeiing van $3,3 miljoen.</p>
<p>Netto instroom van $29,6 miljoen voor Bitwise <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Spot ETF (ETHW); instroom van $74,5 miljoen voor Fidelity Ethereum Spot ETF (FETH); instroom van $19,8 miljoen voor VanEck Ethereum spot ETF (ETHV); netto uitstroom van $326,9 miljoen voor Grayscale Ethereum Spot ETF (ETHE).</p>
<p><strong>Naarmate online activiteit toeneemt, MEW, WIF, en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Memecoins stijgen</strong></p>
<p>Memecoin in het Solana-ecosysteem heeft in de afgelopen zeven dagen aanzienlijke groei doorgemaakt en presteerde beter dan de bredere cryptomarkt. Volgens de gegevens van CoinGecko is de totale marktwaarde van Memecoin op de Solana-blockchain in de afgelopen 7 dagen aanzienlijk gestegen, en bereikte op 24 juli $9,2 miljard.</p>
<p>Cat in Dogs World (MEW) heeft de afgelopen week de grootste stijging gezien, met een stijging van 82% en 1,4% in de afgelopen 24 uur. Direct daarop volgt Gigachad (GIGA), dat in de afgelopen 7 dagen met 45,5% is gestegen en in de afgelopen 24 uur met 9%, waarmee het dubbelcijferige groei heeft bereikt.</p>
<p>Berekend op basis van marktwaarde, zag Dogwifhat (WIF), de grootste meme-token gebaseerd op Solana, op dezelfde dag een stijging van 1,8% in prijs en een stijging van 21,5% binnen een week, waarmee het een marktwaarde van $2,54 miljard bereikte. Het is vermeldenswaardig dat WIF bijna een derde van de totale Memecoin-marktkapitalisatie van Solana vertegenwoordigt. De bullish prestaties van Solana Memecoins weerspiegelen een bredere sentiment onder investeerders in de branche. Volgens een recent rapport van CoinGecko is deze asset class een van de populairste onderwerpen in het tweede kwartaal van 2024 geworden.</p>
<p>Volgens de gegevens van DefiLlama steeg het handelsvolume van Solana van $603,8 miljoen op 29 juni naar $2,54 miljard op 19 juli. Het hoogste transactievolume in de geschiedenis van deze blockchain werd op 15 maart ingesteld op $3,8 miljard. Het aantal actieve adressen op het Solana-netwerk is de afgelopen twee weken sterk gestegen. Het aantal actieve adressen op 23 juli overschreed de 2 miljoen, wat 72% hoger is dan de 1,45 miljoen op 10 juli.</p>
<p><strong>MonoSwap is gehackt en gebruikers is geadviseerd om geen geld te storten</strong></p>
<p>Op 24 juli 2024 kondigde het gedecentraliseerde uitwisselings- en stakingsplatform MonoSwap aan dat het was aanglen door kwaadwillende hackers en waarschuwde gebruikers om op dit moment geen stakingen te doen of extra middelen toe te voegen. MonoSwap onderzoekt dit incident. In de aankondiging waarschuwt MonoSwap gebruikers om onmiddellijk fondsen van het platform op te nemen om verliezen te voorkomen en niet te communiceren met kwaadaardige links die door het protocol zijn geïdentificeerd in socialemediaberichten.</p>
<p>Volgens het platform heeft een van de ontwikkelaars op 23 juli 2024 per ongeluk een kwaadaardige phishing-applicatie geïnstalleerd en is hij gelokt door oplichters die zich voordeden als durfkapitalisten. Tijdens het gesprek heeft de oplichter kwaadaardige software geïnstalleerd op de computer van de ontwikkelaar, die toegang had tot alle wallets en contracten op het platform. Hierdoor kunnen hackers het grootste deel van de staking-liquiditeit op het platform extraheren.</p>
<p>Sinds de medeoprichter van CoinGecko een waarschuwing heeft afgegeven, zijn er meerdere spraakmakende incidenten geweest van hackaanvallen en misbruik van kwetsbaarheden. Onchain detective ZackXBT heeft onlangs een waarschuwing afgegeven aan de <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Samengesteld</a> Financiële website, die gebruikers doorverwees naar phishing pagina’s. Het <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> Finance team heeft dit probleem inmiddels opgelost.</p>
<p><strong>Bitcoin beloningsapplicatie Fold heeft plannen om via $365 miljoen SPAC-handel naar de NASDAQ te gaan.</strong></p>
<p>De Bitcoin-beloningstoepassing Fold heeft plannen om genoteerd te worden aan de NASDAQ door middel van een fusie met het Special Purpose Acquisition Corporation (SPAC) Emerald Acquisition Corp. (EMLD). Na afronding van de transactie zal er meer dan 1.000 Bitcoins ($67 miljoen) op de balans van de entiteit staan.</p>
<p>Fold, gevestigd in New York, heeft een cashback-debetkaart gelanceerd die traditionele beloningen vervangt door het aanbieden van Bitcoin-beloningen. Volgens een aankondiging op woensdag heeft de kaart van Fold meer dan $2 miljard aan transactievolume verwerkt en beloningen ter waarde van meer dan $45 miljoen uitgegeven.</p>
<p>Deze transactie heeft unanieme goedkeuring ontvangen van de raden van bestuur van beide bedrijven, met een voorafgaande transactie-aandelenwaardering van $ 365 miljoen. Na de transactie zullen er meer dan 1.000 Bitcoins ($ 67 miljoen) op de balans van de entiteit staan. Fold heeft nog niet de verwachte voltooiingstijd van de fusie en de handelscode op NASDAQ bekendgemaakt.</p>
<h2 id="h2-Markttrends20de20algehele20markt20is20gedaald20maar20het20marktsentiment20blijft20optimistisch715053"><a name="Markttrends: de algehele markt is gedaald, maar het marktsentiment blijft optimistisch." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: de algehele markt is gedaald, maar het marktsentiment blijft optimistisch.</h2><p>BTC daalde onder de $64.500 en kruiste het midden van de wekelijkse Bollinger Bands. Als BTC deze week kan herstellen en boven het midden van de wekelijkse Bollinger Bands kan komen, wordt nog steeds verwacht dat de markt in de toekomst bullish zal zijn. Als de wekelijkse grafiek echter sluit onder het midden van de Bollinger Bands, kan het blijven fluctueren naar beneden.</p>
<p>ETH is gedaald onder de $3.200. De Grayscale Ethereum ETF blijft grote uitstroom ervaren. Eerder stond de Grayscale Ethereum ETF lange tijd op een negatieve premie van ongeveer -40%, en kopers maakten meer winst door te verkopen, wat enorme druk op de markt veroorzaakte.</p>
<p>Altcoins zijn over het algemeen gedaald en de Meme sector heeft ook een terugval ervaren. Op dit punt kunt u overwegen om in batches de eerder sterke Meme valuta te kopen, wat in de toekomst mogelijk extra rendement kan opleveren.</p>
<p>Marktsentiment: De AHR999-index is vandaag 0,87, wat aangeeft dat de huidige BTC-prijs geschikt is voor langetermijnbeleggingen. De Fear &amp; Greed Index is 68 en het marktsentiment is al vier opeenvolgende dagen hebzuchtig. Ondanks de algemene daling op de markt is het marktsentiment niet in paniek geraakt.</p>
<h3 id="h3-Macroeconomie114759"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Prestaties van Amerikaanse aandelen: de drie belangrijkste Amerikaanse aandelenindices daalden allemaal, waarbij AI-giganten zoals Nvidia en Broadcom de daling leidden en de ‘Big Seven’ Amerikaanse aandelenindex met 5,9% daalde.</p>
<p>Obligatiemarkt: Het rendement van de 30-jarige schatkistobligatie van de Verenigde Staten overtrof het rendement van de vijfjarige schatkistobligatie, de grootste marge sinds mei 2023.</p>
<p>Beleidsverwachting: Na Biden’s terugtrekking uit de verkiezingen is de verwachting van de Federal Reserve om de rente in september te verlagen afgenomen en bevindt de markt zich in een staat van macro-onstabiliteit.</p>
<h3 id="h3-Markt20Hotspots850445"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Solana-ecosysteem:</strong><br>SOL/ETH Prestaties: SOL/ETH blijft versterken, met SOL dat gisteren doorbrak naar $180. Er wordt verwacht dat deze sterke prestatie zich zal voortzetten op de toekomstige markt.</p>
<p>On-chain Memecoins: Memecoins op Solana-keten presteerden goed in deze ronde van stijgende trend, met kat munten POPCAT, MEW, enz. die historische hoogtepunten doorbraken, en Zhaocai Cat Meme Coin MANEKI die meer dan 100% stijging bereikte vanaf de bodem.</p>
<h3 id="h3-Conclusie218407"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>De huidige cryptomarkt presenteert een complexe en volatiele situatie, met belangrijke cryptocurrencies zoals BTC en ETH die onder neerwaartse druk staan, maar de marktsentiment blijft relatief optimistisch. In een neerwaartse trend moeten gebruikers prioriteit geven aan het kopen van sterke tokens op de sterke publieke keten in batches, één voor één. Gezien de onzekerheid van de macro-economie en veranderingen in markthotspots, moeten investeerders voorzichtig blijven, risico’s diversifiëren en prioriteit geven aan investeren in sterke activa.</p>
<h2 id="h2-Macro20De20scherpe20daling20van20technologieaandelen20heeft20de20aandelenmarkt20benvloed20waarbij20zowel20Wall20Street20als20de20Aziatische20markten20zware20verliezen20hebben20geleden386430"><a name="Macro: De scherpe daling van technologieaandelen heeft de aandelenmarkt beïnvloed, waarbij zowel Wall Street als de Aziatische markten zware verliezen hebben geleden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De scherpe daling van technologieaandelen heeft de aandelenmarkt beïnvloed, waarbij zowel Wall Street als de Aziatische markten zware verliezen hebben geleden</h2><p>Op 24 juli daalden de S&amp;P 500- en Nasdaq-indexen tot enkele weken laagtepunten bij de slotkoers van woensdag, omdat de lagere prestaties van Alphabet en Tesla het vertrouwen van beleggers in aandelen met grote marktkapitalisatie verzwakten.</p>
<p>Beleggers wachten op de eerste aankondiging van een van de ‘Big Seven’ bedrijven over hun kwartaalprestaties om te bepalen of hoge waarderingen redelijk zijn. De prestaties van deze zeven bedrijven hebben een aanzienlijke impact op de markt en zullen ongetwijfeld een breed scala aan kettingreacties hebben op de algehele markt.</p>
<p>De belangrijkste indexprestaties zijn als volgt: de Dow Jones Index daalde met 1,25%, de S&amp;P Index daalde met 2,31% en de Nasdaq Index daalde met 3,64%.</p>
<p>Op donderdagochtend 25 juli werden Aziatische aandelenmarkten hard getroffen door de prestaties van technologie-aandelen en investeerders grepen naar laag-risico activa, waaronder kortlopende obligaties, de Japanse yen en de Zwitserse frank.</p>
<p>De meest gebruikte aandelenindex van de MSCI Asia Pacific daalde met 0,7%, de Nikkei-index van Japan kelderde met 2,9% en de KOSPI-index van Zuid-Korea daalde met 2%. De Taiwanese markt blijft gesloten vanwege de impact van de tyfoon. Chinese blue-chip aandelen verminderden hun eerdere daling met 0,1%, terwijl de Shanghai Composite Index met 0,3% daalde en een dieptepunt van vijf maanden bereikte. De Hang Seng Index in Hong Kong daalde met 0,6%, ondanks de laatste versoepelingsmaatregelen van Peking, slaagde het er niet in voldoende steun te bieden.</p>
<p>De paniekindex van Wall Street is gestegen tot een hoogtepunt van drie maanden. Beleggers zijn op zoek naar veilig geld en zeer liquide kortlopende schulden, waarbij de Amerikaanse tweejarige obligatierendementen op woensdag daalden tot het laagste niveau in bijna zes maanden.</p>
<p>De Japanse yen, als veilige haven valuta, steeg met 0,6%, waarmee het zijn hoogste niveau bereikte in twee en een halve maand. ‘s Nachts steeg de Japanse yen met 1,1% en de opwaartse trend blijft sterk voorafgaand aan de vergadering van de centrale bank volgende zondag, waar beleidsmakers zullen bespreken of de rente moet worden verhoogd. De Zwitserse frank steeg ook met 0,7% gedurende de nacht.</p>
<p>De People’s Bank of China heeft onverwachts de lange rentetarieven verlaagd en recente stimuleringsmaatregelen verhoogd, maar de Chinese aandelenmarkt kreeg niet veel steun.</p>
<p>De daling van de aandelenmarkt heeft ertoe geleid dat beleggers hun inzet op wereldwijde renteverlagingen hebben verhoogd, waarbij de futuresmarkten een kans van 100% laten zien dat de Federal Reserve de rentetarieven in september verlaagt. De piek in marktvolatiliteit heeft geleid tot een aanzienlijke vermindering van arbitragehandel, waardoor de Amerikaanse dollar op donderdag nog eens 0,6% daalde ten opzichte van de Japanse yen tot 152,85.</p>
<p>Geconfronteerd met de ineenstorting gedomineerd door large cap aandelen, heeft de markt de winstvooruitzichten van zwaar gehypete kunstmatige intelligentie en de zeven grote gigantische aandelen opnieuw bekeken. De scherpe daling van Alphabet en Tesla heeft de ineenstorting van Wall Street veroorzaakt. Bovendien hebben zorgen over China en de mondiale economische groei enorme druk gelegd op grondstof-gekoppelde valuta, en de risico-aversie op de Chinese en Japanse markten zal aanhouden.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gedaald en blijven ze dicht bij een zes weken laag, vanwege zorgen over de economische vertraging in China die de vraag onderdrukt. Brent ruwe olie futures daalden met 0,4% tot $81,81 per vat, terwijl de Amerikaanse West Texas Intermediate (WTI) futures ook met 0,3% daalden tot $77,33 per vat.</p>
<p>Goud daalde met 0,9% naar $2.375,92 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 beleggingsaanbevelingen.<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>