RGFnZWxpamtzIG5pZXV3cyB8IFZpdGFsaWsgQnV0ZXJpbiBvbmRlcnN0ZXVudCBNZWdhRVRIIEJsb2NrY2hhaW4sIFByb2plY3RmaW5hbmNpZXJpbmcgJDIwTTsgQmxhc3Qgc3RlZWcgbWV0IDQwJSBuYSBBaXJkcm9wOyBVU0RULWFhbmJvZCBvcCBUT04gb3ZlcnNjaHJlZWQgNTAwTQ==

2024-06-28, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17195474951_21.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Vitalik20Buterin20ondersteunt20het20MegaETH20blockchainproject20in20het20nieuwe20gebied20met20een20projectfinanciering20van202020miljoen20de20Blasttoken20steeg20met204020na20een20airdrop20de20USDTvoorraad20op20TON20heeft20de2050020miljoen20overschreden661447"><a name="Crypto Dagelijks Overzicht: Vitalik Buterin ondersteunt het MegaETH blockchain-project in het nieuwe gebied, met een projectfinanciering van $20 miljoen; de Blast-token steeg met 40% na een airdrop; de USDT-voorraad op TON heeft de 500 miljoen overschreden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Vitalik Buterin ondersteunt het MegaETH blockchain-project in het nieuwe gebied, met een projectfinanciering van $20 miljoen; de Blast-token steeg met 40% na een airdrop; de USDT-voorraad op TON heeft de 500 miljoen overschreden</h2><p>Allereerst, laten we de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens hebben Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 27 juni $11,4 miljoen aan uitstroom van fondsen ervaren; Ondertussen had Fidelity Bitcoin Spot ETF (FBTC) een instroom van $6,7 miljoen, Bitwise Bitcoin Spot ETF (BITB) had een instroom van $8 miljoen, ARK 21Shares Bitcoin Spot ETF (ARKB) had een instroom van $1,8 miljoen en WisdomTree Bitcoin Spot ETF (BTCW) had een netto-instroom van $6,6 miljoen.</p>
<p><strong>Vitalik Buterin ondersteunt de nieuwe blockchain MegaETH en haalt $20 miljoen op met een tokenwaardering van 9 cijfers.</strong><br>Shuyao Kong, mede-oprichter en Chief Business Officer van MegaLabs, onthulde aan The Block dat het bedrijf in december vorig jaar begon met seed-financiering en deze in mei van dit jaar afrondde. Kong verklaarde dat deze financieringsronde een structuur van eigen vermogen en tokenwarrants aanneemt, wat resulteert in de volledig verwaterde tokenwaardering van MegaETH die “negen cijfers” of ten minste $ 100 miljoen bereikt.</p>
<p>MegaLabs kondigde donderdag aan dat Dragonfly de leiding heeft genomen in de zaadronde van financiering, met andere deelnemers waaronder Segment Capital, Robot Ventures, Big Brain Holdings en anderen. Angel-investeerders zijn onder andere Vitalik Buterin, mede-oprichter van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Joseph Lubin, oprichter en CEO van ConsenSys, en Sreem Kannan, oprichter en CEO van EigenLayer.</p>
<p>Kong legde uit dat het idee achter MegaETH blockchain komt van het feit dat de meeste <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM) compatibele blockchains slechts transactievolumes van drie cijfers per seconde (TPS) kunnen bereiken, terwijl het doel van MegaETH is om 100.000 TPS te bereiken. MegaETH beweert de eerste volledig Ethereum compatibele ‘real-time blockchain’ te zijn - ‘real-time’ betekent dat MegaETH ‘in real-time kan verwerken en resultaten kan bijwerken zodra transacties binnenkomen.’ Ondersteunt hoge transactie doorvoer en krachtige rekenkracht.</p>
<p>MegaETH maakt gebruik van de beveiliging van Ethereum. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> MegaETH maakt gebruik van een foutpreventiesysteem en een geoptimaliseerde sorter om realtime prestaties te bereiken. De twee belangrijkste technologieën van MegaETH - heterogene blockchain-architectuur en een ‘super geoptimaliseerde’ EVM-uitvoeringsomgeving zijn cruciaal. MegaLabs stelt dat heterogene blockchain-architecturen de prestaties verbeteren door netwerknodes met verschillende hardwareconfiguraties specifieke taken te laten uitvoeren, terwijl ultra geoptimaliseerde EVM-uitvoeringsomgevingen de doorvoer, latentie en resource-efficiëntie tot de hardwarelimieten pushen.</p>
<p>Kong onthulde dat MegaETH’s publieke testnet in het begin van de herfst zal worden gelanceerd en dat het mainnet naar verwachting tegen het einde van het jaar zal worden gelanceerd. Op de vraag of MegaETH’s inheemse tokens gelijktijdig met het mainnet zullen worden gelanceerd, verklaarde Kong dat er nog geen beslissing is genomen.</p>
<p><strong>De Blast-token steeg met 40% na ontvangst van zijn eerste $2 miljard airdrop</strong><br>De native token Blast (BLAST) van het Ethereum Layer 2-netwerk is met 40% gestegen sinds de lancering en presteert beter dan andere langverwachte airdrops die de afgelopen weken op de markt zijn gekomen. Volgens de samenvattende gegevens van Ambient Finance en het handelsplatform ‘Aevo’ is de initiële aanbiedingsprijs van BLAST $0,02 per aandeel, met een volledig verwaterde waarde (FDV) van $2 miljard bij de lancering.</p>
<p>Volgens gegevens van CoinMarketCap is de prijs van BLAST met meer dan 40% gestegen. Dit staat in schril contrast met de recente spraakmakende tokenuitgifte, waaronder het Ethereum Layer 2-netwerk zkSync (ZK) en cross-chain interoperabiliteit LayerZero (ZRO). Deze twee soorten tokens zijn sinds hun uitgifte met respectievelijk 46% en 43% gedaald.</p>
<p>Deze airdrop heeft 17% van de totale BLAST-voorraad vrijgegeven, waarvan 7% is toegewezen aan gebruikers die Ethereum overbruggen, nog eens 7% is toegekend aan gebruikers die ‘hebben bijgedragen aan het succes van gedecentraliseerde applicaties (DApps) op het netwerk,’ en 3% is toegekend aan de Blur Foundation voor toekomstige airdrops aan haar gemeenschap.</p>
<p><strong>De USDT-voorraad op de TON-blockchain heeft de 500 miljoen overschreden</strong><br>Het nettoverkeer van stablecoin USDT op het TON-netwerk heeft de 500 miljoen overschreden. Volgens het USDT-aanboddashboard van The Block stonden er op dinsdag in totaal 5192,8 miljoen USDT-stablecoins op het TON-netwerk.</p>
<p>Ongeveer twee maanden geleden, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> lanceerde stablecoins gekoppeld aan de Amerikaanse dollar en het stablecoin XAUT van het bedrijf gekoppeld aan goud op TON. Open Network kondigde via zijn officiële Telegramkanaal aan: “Het feit dat je gemakkelijk digitale dollars naar iedereen overal kunt sturen, net als het versturen van een sms, is een praktisch gebruiksscenario dat USDT/TON onderscheidt.”</p>
<p>De toename van TON-netwerkactiviteiten kan ook worden toegeschreven aan de toenemende populariteit van speelbare crypto-minigames op Telegram. Spellen zoals Dotcoin, Catizen en Hamster Kombat hanteren eenvoudige mechanismen waarmee gebruikers spelmunten kunnen verdienen, waarmee ze mogelijk echte token-luchtdroppings kunnen winnen.</p>
<p>Aan het begin van deze maand overschreed de totale vergrendelingswaarde van het TON blockchain $600 miljoen, wat twee keer de vergrendelingswaarde was van drie weken geleden. Volgens de gegevens van DefiLlama heeft TON momenteel meer dan $670 miljoen. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>, de inheemse cryptocurrency van TON blockchain, is ook de negende grootste cryptocurrency ter wereld geworden met een marktwaarde van $18,5 miljard.</p>
<h2 id="h2-Markttendensen572901"><a name="Markttendensen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttendensen</h2><p>BTC is op en neer gegaan en is nu weer boven de $62.000; ETH presteerde sterk, nog maar één stap verwijderd van $3.500; SOL steeg met 10% binnen een dag, wat leidde tot de algemene stijging van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteemtokens. Op macro-economisch vlak steeg de Amerikaanse aandelenmarkt toen het debat over de Amerikaanse presidentsverkiezingen vandaag begon.</p>
<h3 id="h3-Markt20Hotspots184110"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Solana-ecosysteem: VanEck heeft de eerste aanvraag voor een SOL ETF ingediend, wat een stijging van meer dan 10% in SOL op één dag heeft veroorzaakt, waardoor het boven de $150 is teruggekeerd. SOL is gestegen, waardoor ook ecosysteemtokens zoals BOME, POPCAT, WEN, RAY, JUP, enz. zijn gestegen, waarbij Meme op de Solana-keten opvallender presteert.</p>
<p>Ethereum-ecosysteem: marktnieuws toont aan dat ETH ETF vóór 4 juli zal worden goedgekeurd en de ETH/BTC-wisselkoers blijft versterken. De MOG, MKR, ENS en andere componenten van het Ethereum-ecosysteem zijn aanzienlijk toegenomen.</p>
<p>DePIN-sector: De DePIN-sector steeg over het algemeen, waarbij MOBILE, AKT, IO, HNT en andere sectoren aanzienlijke winsten boekten. AKT is de inheemse token van Akash Network, een gedecentraliseerde cloud computing markt met een huidige circulerende marktwaarde van ongeveer $870 miljoen, en staat op de 79e plaats wat betreft marktwaarde.</p>
<h2 id="h2-Macro20Beleggers20houden20de20inflatiegegevens20in20de20gaten20en20Wall20Street20sloot20vlak20De20Aziatische20markt20is20vijf20opeenvolgende20maanden20gestegen50128"><a name="Macro: Beleggers houden de inflatiegegevens in de gaten en Wall Street sloot vlak; De Aziatische markt is vijf opeenvolgende maanden gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Beleggers houden de inflatiegegevens in de gaten en Wall Street sloot vlak; De Aziatische markt is vijf opeenvolgende maanden gestegen</h2><p>Op donderdag 27 juni sloot de Amerikaanse aandelenmarkt vlak af omdat investeerders wachtten op nieuwe inflatiegegevens, die wijzen op een aanhoudende vertraging van de economische activiteit en de marktverwachtingen van renteverlagingen verhogen. De marktprestaties voor de rest van deze week waren relatief teleurstellend, terwijl vrijdag vol zat met risicovolle gebeurtenissen, zoals de Democratische president Joe Biden en Republikeinse tegenstander Donald Trump die hun eerste presidentsdebat hielden in Atlanta.</p>
<p>De prestaties van de drie belangrijkste indices zijn als volgt: Nasdaq steeg met 0,3%, S&amp;P steeg met 0,09% en Dow Jones steeg met 0,09%. Marktpartijen uiten bezorgdheid over de duurzaamheid van deze stijging en stellen voor om beleggingsportefeuilles te diversifiëren om zich in te dekken tegen mogelijke aanzienlijke verliezen.</p>
<p>Vorige week is het aantal aanvragen voor werkloosheidsuitkeringen gedaald tot 233.000, lager dan de verwachte 236.000. Bovendien tonen de definitieve gegevens aan dat de Amerikaanse economie in het eerste kwartaal boven verwachting is gegroeid. Uit de gegevens bleek dat de economische activiteit doorging maar vertraagde, en het rendement van de benchmark 10-jarige en tweejarige schatkistobligaties daalde.</p>
<p>Op 28 juni stegen de Aziatische aandelenmarkten op vrijdag en markeerden daarmee de vijfde opeenvolgende maand van winst. De markt verwacht dat de afkoeling van de Amerikaanse inflatie zal leiden tot het versoepelen van het rentebeleid door de Federal Reserve dit jaar. De MSCI Asia Pacific aandelenindex exclusief Japan daalde met 0,03%; Ondanks de zwakte van de Japanse yen is de Nikkei-index positief, met de laatste stijging van meer dan 1%. De Hang Seng Index in Hongkong daalde met 0,1%, terwijl de referentie-index in China licht daalde met 0,05%.</p>
<p>Ondertussen zal de kernindex voor persoonlijke consumptie-uitgaven (PCE) voor mei in de Verenigde Staten later op vrijdag worden vrijgegeven, wat mogelijk meer duidelijkheid kan bieden over het vooruitzicht voor de Amerikaanse rentetarieven.</p>
<p>Wat betreft grondstoffen stegen de futures voor Brent ruwe olie met 0,39% tot $86,73 per vat, terwijl de futures voor ruwe olie van West Texas Intermediate in de Verenigde Staten met 0,42% stegen tot $82,08 per vat.</p>
<p>Goud had het moeilijk onder druk van de versterkende Amerikaanse dollar en daalde met 0,26% tot $2.321,19 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 zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>