RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBlbiBFVEggaGVyc3RlbGRlbjsgVE9OIEFwcCBDaGFpbiB3ZXJrdGUgc2FtZW4gbWV0IFBvbHlnb24gb20gVE9OIEwyIHRlIGxhbmNlcmVuOyBIZXQgWC1hY2NvdW50IHZhbiB6YW5nZXJlcyBEb2phIENhdCBpcyBnZWhhY2t0IG9tIGZyYXVkdWxldXplIG11bnRlbiB0ZSBwcm9tb3Rlbg==

2024-07-10, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/17205828641_8.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20TON20App20Chain20heeft20samengewerkt20met20Polygon20om20TON20L220te20lanceren20Het20Xaccount20van20zanger20Doja20Cat20is20gehackt20om20frauduleuze20munten20te20promoten20De20prijs20van20Meme20Coin20gepromoot20door20Messi20steeg20met20350811531"><a name="Crypto Dagelijkse Samenvatting: TON App Chain heeft samengewerkt met Polygon om TON L2 te lanceren; Het X-account van zanger Doja Cat is gehackt om frauduleuze munten te promoten; De prijs van Meme Coin, gepromoot door Messi, steeg met 350%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: TON App Chain heeft samengewerkt met <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> om TON L2 te lanceren; Het X-account van zanger Doja Cat is gehackt om frauduleuze munten te promoten; De prijs van Meme Coin, gepromoot door Messi, steeg met 350%.</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 9 juli een uitstroom van $37,5 miljoen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $91 miljoen, Bitwise Bitcoin spot ETF (BITB) had een uitstroom van $4,7 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) had een instroom van $43,3 miljoen.</p>
<p>Onlangs hebben BTC en ETH aanzienlijke terugtrekkingen meegemaakt. Verschillende instellingen hebben echter ETH spot ETF S-1 formulieren ingediend, en de S-1 documenten voor ETH spot ETF’s kunnen in juli goedkeuring van de SEC ontvangen, mogelijk volgende week.</p>
<p><strong>TON Application Chain werkte samen met <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> om Nieuwe TON L2 te lanceren</strong></p>
<p>TON Application Chain (TAC) en Polygon Labs hebben de introductie aangekondigd van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Door deze samenwerking integreert TON L2 de functionaliteit van de Virtual Machine (EVM) in het TON-ecosysteem. Hierdoor kunnen gedecentraliseerde applicaties (DApps) die compatibel zijn met EVM worden uitgevoerd op TAC met behulp van Polygon CDK en het interoperabiliteitsprotocol Agglayer.</p>
<p>Deze zet heeft tot doel het toepassingsgebied van het TON-netwerk uit te breiden, waarbij meerdere gebieden zoals gedecentraliseerde financiering (DeFi), gaming en identiteitsoplossingen worden bestreken. TAC CEO Pavel Altukhov verklaarde in een interview met Cointelgraph dat EVM-compatibiliteit de barrières voor het gebruik van TON-netwerken zal doorbreken, wat naar verwachting sterke interesse zal opwekken in DeFi- en GameFi-toepassingen.</p>
<p>Op dit moment zijn er geen EVM-compatibele applicaties op het TON-netwerk. Het overbruggingsproces is complex en duur, en alleen crypto-inheemse gebruikers kunnen het soepel gebruiken. Daarnaast heeft TON onlangs USDT geïntegreerd en de Tap to Earn-applicatie genaamd Notcoin gelanceerd, wat het aantal maandelijkse actieve on-chain wallets van Telegram heeft doen stijgen naar 5,8 miljoen.</p>
<p>Via toepassingen zoals Wallet in Telegram zal integratie die compatibel is met EVM <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ontwikkelaars in staat stellen om toegang te krijgen tot een groot aantal gebruikers op Telegram, waardoor meer crypto-toepassingen in de echte wereld mogelijk worden. Bijvoorbeeld DeFi-toepassingen, games, en gedecentraliseerde identiteitsoplossingen.</p>
<p>Volgens blockchain-analysebedrijf Messari overtrof het aantal dagelijks actieve adressen op het TON-netwerk in juni 2024 dat van Ethereum. Echter, met de snelle ontwikkeling van het TON-ecosysteem zijn phishingaanvallen ook toegenomen. Op 24 juni waarschuwde SlowMist-oprichter Yu Xian dat het Telegram-ecosysteem ‘te vrij’ was en dat phishinglinks werden verspreid via de berichtengroepen, airdrops en andere ‘misleidende middelen’ van het platform.</p>
<p><strong>Het account van zangeres Doja Cat is gehackt om frauduleuze munt te promoten.</strong></p>
<p>Zangeres Doja Cat waarschuwde op 8 juli dat haar X-account met 5,6 miljoen volgers is gehackt om te promoten. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> op basis van token DOJA. De hacker plaatste een bericht op hun account met de tekst “koop $DOJA, anders” en voegde het <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> contractadres voor de token toe.</p>
<p>Doja Cat verduidelijkte later aan 24 miljoen fans op haar Instagram dat deze misleidende X-berichten niet van haar waren. Volgens het celebrity nieuwsaccount Daily Trends werd het X-account van Doja Cat op 8 juli gehackt en gebruikt als een frauduleuze token om de naam van deze rapper te promoten. Bovendien meldde de celebrity nieuwswebsite Daily Mail ook dat het account van Doja Cat door hackers werd gebruikt om negatieve berichten over rapper Iggy Azalea te plaatsen.</p>
<p>De frauduleuze token “Doja Cat (DOJA)” bereikte ooit een marktkapitalisatie van $1,65 miljoen na promotie op gestolen accounts, maar viel snel terug naar $16820, waardoor investeerders meer dan $1,63 miljoen verloren. Volgens DEXScreener-gegevens steeg de prijs van de token naar $0,001656 in het eerste uur na de lancering, maar daalde toen sterk. Op het moment van publicatie van dit artikel is de prijs van de token $0,00001682 en is de marktwaarde slechts $16.820.</p>
<p><strong>Messi promoot Meme Coin op Instagram, waardoor de prijzen met 350% stijgen</strong></p>
<p>Voetballegende Lionel Messi promootte de op Solana gebaseerde meme-munt WATER op zijn Instagram, waardoor de prijs van de token binnen twee uur met 350% steeg. Messi deelde een foto van het token-mascotte en voegde een <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> naar de Instagram-pagina van het project. Na het plaatsen sprong de waterprijs van $0.00032 naar $0.00146.</p>
<p>Volgens CoinMarketCap-gegevens is WATER vervolgens gedaald, met prijzen iets boven de $0.001 op het moment van schrijven, en een stijging van 215,6% in de afgelopen 24 uur. De marktwaarde van deze token is ongeveer $94 miljoen, met een handelsvolume van 24 uur iets onder de $40 miljoen. De website van het project beweert dat WATER tot doel heeft een positieve impact te hebben op de echte wereld via filantropie, maar specificeert niet de specifieke uitvoeringsmethode.</p>
<p>De overstap van Messi heeft kritiek uitgelokt vanuit de cryptogemeenschap. Sommige commentatoren hebben erop gewezen dat de eerder door Messi gepromote Leafty en Planet projecten beide problemen hebben ondervonden, waarbij de eerste slechts vijf dagen na de promotie de liquiditeit verloor, terwijl de waarde van de laatste sinds de promotie met 90% is gedaald.</p>
<h2 id="h2-Markttrends20BTC20herstelt20en20schommelt20op20hoog20niveau20en20het20marktsentiment20blijft20angstig44390"><a name="Markttrends: BTC herstelt en schommelt op hoog niveau, en het marktsentiment blijft angstig" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC herstelt en schommelt op hoog niveau, en het marktsentiment blijft angstig</h2><p><strong>BTC</strong><br>Huidige prijs: ongeveer $57.700, hoog herstellend en fluctuerend, consoliderende trend</p>
<p>Marktdynamiek: De voortdurende grote instroom van Bitcoin spot ETF’s toont een sterke vraag van institutionele beleggers aan</p>
<p><strong>ETH</strong><br>Huidige prijs: Boven $ 3.050 is de trend relatief sterk en blijft deze terugveren</p>
<p>Invloedfactoren: Ethereum spot ETF kan volgende maandag worden goedgekeurd.</p>
<p><strong>Altcoins</strong><br>Trend: De stijging en daling zijn gemengd, met de Meme coin sector die het beter doet, wat wijst op een voorkeur voor speculatieve fondsen.</p>
<p><strong>Marktindicatoren</strong><br>AHR999-index: Op 0.71 (geschikt voor regelmatige investeringen)</p>
<p>Angst en hebzucht index: Op 28 (marktsentiment nog steeds in een staat van angst)</p>
<h3 id="h3-Macroeconomie67808"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Trend van de Amerikaanse aandelenmarkt: ups en downs zijn gemengd en de marktsentiment is relatief voorzichtig</p>
<p>Beslissing over de rentevoet van de Federal Reserve: De waarschijnlijkheid dat de rentevoeten in augustus ongewijzigd blijven, bedraagt 95,3%, wat aangeeft dat de verwachtingen van de markt met betrekking tot het beleid van de Federal Reserve relatief stabiel zijn.</p>
<h3 id="h3-Markt20Hotspots472306"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Ethereum Domeinnaam Protocol (ENS)</strong><br>Prijsfluctuatie: ENS raakte gisteren kortstondig $34 aan, met een intraday amplitude die 30% overschreed</p>
<p>Marktprestaties: sterke prestaties in deze ronde van de markt, aanzienlijk beter dan andere Ethereum ecosysteem tokens</p>
<p>Influencerende factoren: Ontving meerdere vermeldingen en zegeningen van de oprichter van Ethereum, Vitalik Buterin, en ging gisteren online op de Koreaanse Effectenbeurs</p>
<p><strong>Meme Coin Sector</strong><br>Belangrijkste munten: POPCAT, MOG, BONK, BRETT en andere munten stegen</p>
<p>Marktdynamiek: Solana Chain blijft cat-achtige Meme-munten opvoeren, en de Bonk-community heeft een voorstel ingediend om een groot aantal BONKs te verbranden, wat de prijzen mogelijk verder kan opdrijven</p>
<p><strong> Privacy Coin Sector</strong><br>Belangrijkste munten: ZEN, ZEC</p>
<p>Prijs trend: Meer dan 10% stijging binnen de dag</p>
<h3 id="h3-Samenvatting411193"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h3><p>De huidige markt vertoont een relatief complexe situatie en de sterke opleving van Bitcoin en Ethereum heeft enige ondersteuning voor de markt geboden, maar het algemene marktsentiment verkeert nog steeds in een staat van angst. Meme-munten hebben een uitstekende prestatie geleverd, waaruit de marktvoorkeuren voor specifieke sectoren blijken. De macro-economische omgeving is relatief stabiel en de duidelijke beleidsverwachtingen van de Federal Reserve dragen bij aan de korte termijn stabiliteit van de markt.</p>
<h2 id="h2-Macro20Verwachtingen20voor20renteverlagingen20nemen20toe20SampP2050020en20Nasdaq20bereiken20nieuwe20hoogtepunten20Aziatische20aandelenmarkten20dalen233371"><a name="Macro: Verwachtingen voor renteverlagingen nemen toe, S&amp;P 500 en Nasdaq bereiken nieuwe hoogtepunten, Aziatische aandelenmarkten dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Verwachtingen voor renteverlagingen nemen toe, S&amp;P 500 en Nasdaq bereiken nieuwe hoogtepunten, Aziatische aandelenmarkten dalen</h2><p>Op 9 juli vertelde Federal Reserve-voorzitter Jerome Powell aan wetgevers dat meer ‘goede’ economische gegevens redenen zullen zijn voor renteverlagingen, wat de S&amp;P 500- en Nasdaq-indices naar nieuwe slotkoersen stuwt.</p>
<p>Onder de drie belangrijkste indices steeg de S&amp;P 500-index met 0,07%, steeg de Nasdaq-index met 0,14% en daalde de Dow Jones-index met 0,13%. Dit is de zesde opeenvolgende keer dat de Nasdaq-index een nieuw slotrecord heeft behaald, en de vijfde opeenvolgende keer dat de S&amp;P 500-index een nieuw slotrecord heeft behaald. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> De groei van kunstmatige intelligentie in de Amerikaanse bedrijfssector heeft de onzekerheid over het renteverlagingsbeleid van de Federal Reserve gecompenseerd.</p>
<p>Bij grote bedrijfsaandelen steeg de aandelenkoers van AI-chipfabrikant Nvidia met 2,5%, waardoor de daling van andere chipaandelen werd gecompenseerd. De aandelenkoers van Microsoft daalde met 1,4%, terwijl de aandelenkoers van Tesla met 3,7% steeg.</p>
<p>Powell toonde zich zekerder over een terugval in de inflatie, maar onthulde niet de specifieke timing van renteverlagingen later dit jaar. Tijdens zijn getuigenis in het Congres noemde hij dat hoewel de inflatie nog steeds boven het streefcijfer van 2% ligt, er in de afgelopen maanden enige verbetering is geweest en dat ‘meer goede gegevens’ de redenering voor renteverlagingen zullen versterken.</p>
<p>Op 10 juli openden Aziatische aandelenmarkten woensdag iets lager. De MSCI Asia Pacific aandelenindex daalde in de vroege handel met 0,27%, na eerder deze week tot een hoogtepunt van meer dan twee jaar te zijn gestegen. De Nikkei-index van Japan steeg met 0,08% vanwege de verzwakking van de yen.</p>
<p>Op de valutamarkt is de Amerikaanse dollar relatief stabiel gebleven, met GBP/USD op $1.2787 en EUR/USD die met 0,01% daalt naar $1.0813. De Nieuw-Zeelandse dollar steeg met 0,05% naar $0.6128, en de Reserve Bank of New Zealand (RBNZ) zal later die dag haar rentebesluit bekendmaken. De markt verwacht dat de RBNZ een havikachtige houding zal handhaven en slechts één keer de rente zal verlagen tegen het einde van het jaar.</p>
<p>Met betrekking tot grondstoffen toonde een sectorrapport een daling van de Amerikaanse ruwe olie- en brandstofvoorraden van vorige week, wat wijst op een stabiele vraag. In combinatie met verbeterde vooruitzichten voor renteverlagingen herstelden de olieprijzen zich na drie opeenvolgende dagen van daling. De future van Brent ruwe olie steeg met 0,24% naar $84,86 per vat, terwijl de future van West Texas Intermediate (WTI) in de Verenigde Staten met 0,29% steeg naar $81,65 per vat.</p>
<p>De prijs van goud steeg met 0,07% tot $2.365,09 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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>