RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0byBtYXJrdCBkYWFsdCBvdmVyIGhldCBhbGdlbWVlbjsgQWV0aGlyIGxhbmNlZXJ0IGVlbiBnZWRlY2VudHJhbGlzZWVyZCBjbG91ZG5ldHdlcmsgb3AgRXRoZXJldW07IE5FQVIgRm91bmRhdGlvbiByaWNodCBOdWZmbGUgTGFicyBvcCBlbiBoYWFsdCAkMTNNIGFhbiBmaW5hbmNpZXJpbmcgb3A

2024-06-14, 03:46

<p><img src="https://gimg2.gateimg.com/image/article/17183366841_10.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Aethir20lanceerde20een20gedecentraliseerd20cloudnetwerk20op20het20Ethereummainnet20De20NEAR20Foundation20richtte20Nuffle20Labs20op20en20haalde201320miljoen20aan20financiering20op20Als20gevolg20van20misbruikers20die20120miljard20nieuwe20tokens20slaan20zijn20de20HLGprijzen20met20meer20dan206020gedaald244162"><a name="Crypto Daily Digest: Aethir lanceerde een gedecentraliseerd cloudnetwerk op het Ethereum-mainnet; De NEAR Foundation richtte Nuffle Labs op en haalde $13 miljoen aan financiering op; Als gevolg van misbruikers die 1 miljard nieuwe tokens slaan, zijn de HLG-prijzen met meer dan 60% gedaald" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Aethir lanceerde een gedecentraliseerd cloudnetwerk op het Ethereum-mainnet; De NEAR Foundation richtte Nuffle Labs op en haalde $13 miljoen aan financiering op; Als gevolg van misbruikers die 1 miljard nieuwe tokens slaan, zijn de HLG-prijzen met meer dan 60% gedaald</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 de gegevens van Farside Investor ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 13 juni nog steeds uitstroom van $61,5 miljoen aan fondsen; Ondertussen ondervond Fidelity Bitcoin spot ETF (FBTC) uitstroom van $106,4 miljoen, had Bitwise Bitcoin spot ETF (BITB) een instroom van $9,8 miljoen, en had ARK 21 Shares Bitcoin spot ETF (ARKB) een instroom van $52,7 miljoen.</p>
<p><strong>Aethir lanceerde een gedecentraliseerd cloudnetwerk op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> hoofdnetwerk</strong><br>Aethir, een gedecentraliseerde fysieke infrastructuur netwerk (DePIN) aanbieder heeft aangekondigd dat haar gedecentraliseerde cloud computing netwerk officieel is gelanceerd op het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> mainnet. Ondernemingen, datacenters, andere cloud providers en crypto mining operators kunnen ongebruikte GPU bronnen bijdragen aan Aethirs GPU als een service oplossing netwerk.</p>
<p>Aethir stelt bedrijven en ontwikkelaars in staat om rekenresources te huren van hun leveranciersnetwerken om de training van kunstmatige intelligentie (AI) modellen of grootschalige digitale contentpresentatie te ondersteunen. Aethir maakt gebruik van Ethereum om zijn stakingsfunctie te implementeren via de inheemse ATH-tokens en gebruikt Arbitrum (ARB) voor snelle betalingen om rekenproviders en checker-nodes te belonen, wat zorgt voor kwaliteit.</p>
<p>Tijdens de testnetfase trok Aethir meer dan 500.000 gebruikers aan, bereikte nodesales van $146 miljoen en kreeg ondersteuning van Nvidia, Super Micro, HPE en Foxconn.</p>
<p>Wat betreft gegevensbeveiliging en privacy verklaarde mede-oprichter van Aethir, Mark Rydon, dat netwerkbeveiligingsmaatregelen onder meer netwerktoegangscontrole en anti-DDoS-aanvallen omvatten, met toegewijde hardware firewalls die de gegevensbeveiliging beschermen. Klanten zijn altijd de eigenaars en gebruikers van gegevens, en deze gegevens worden niet alleen veilig en vertrouwelijk bewaard voor externe bezoekers, maar ook voor interne bezoekers.</p>
<p><strong>NEAR Foundation heeft een onafhankelijke entiteit, Nuffle Labs, opgericht en heeft $13 miljoen aan financiering opgehaald.</strong><br>De NEAR Foundation heeft de oprichting van een onafhankelijke entiteit genaamd Nuffle Labs aangekondigd en heeft met succes $13 miljoen aan strategische financiering opgehaald. Nuffle Labs is verantwoordelijk voor de ontwikkeling van de data beschikbaarheidslaag (NEAR DA), NEAR snelle finalisatielaag (NFFL) en andere producten in de NEAR modulaire productreeks voor NEAR. Deze financiering wordt geleid door Electric Capital, met strategische financiering van de NEAR Foundation en deelname van meerdere investeringsinstellingen.</p>
<p>Andere investeerders zijn onder meer Canonical Crypto, Fabric Ventures, Robot Ventures, Caladan, Lyrik Ventures en engeleninvesteerders zoals Jordi Alexander van Selini, Bowen Wang van NEAR, Sriram Kannan van EigenLayer, Sam Kazemian van <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, en Sandeep Nailwal van <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>.</p>
<p>Als onafhankelijke entiteit kan Nuffle Labs flexibelere beslissingen nemen en ervoor zorgen dat NEAR modulaire producten concurrerend blijven. Het bedrijf zal gebruik maken van de voordelen van de NEAR Foundation, Ethereum en EigenLayer ecoen om de efficiëntie en veerkracht van het NEAR ecosysteem te verbeteren.</p>
<p>De NEAR Foundation is verantwoordelijk voor het toezicht op het NEAR-protocol, een platform waarmee ontwikkelaars gedecentraliseerde toepassingen kunnen bouwen. Ondertussen is de NEAR-token in de afgelopen 24 uur met 4,9% gedaald en heeft momenteel een prijs van $5,95.</p>
<p><strong>Als gevolg van exploitanten die 1 miljard nieuwe tokens slaan, zijn de HLG-prijzen met meer dan 60% gedaald</strong><br>Volgens de gegevens van CoinGecko kenden de inheemse tokens van het Hologram-protocol (HLG) een prijsdaling van 60% nadat een kwaadwillende actor misbruik had gemaakt van een kwetsbaarheid om 1 miljard HLG-tokens te maken. On-chain gegevens tonen aan dat de ENS-portemonnee acc01ade.eth betrokken was bij deze aanval. De Github-pagina toont aan dat de portemonnee ook een bijdrager is aan het project.</p>
<p>Op basis van de huidige marktprijzen is de waarde van de 1 miljard HLG die door uitbuiters is verduisterd iets hoger dan $6,7 miljoen. Het Hologram-protocol wordt op zijn website beschreven als een oplossing om een enkel contractadres te bereiken op alle EVM-blockchains, waarbij consistente tokenisatie, naadloze interoperabiliteit en veilige cross-chain-activatransfer worden gegarandeerd.</p>
<p>Het Holograph-team verklaarde dat ze de kwetsbaarheid hebben verholpen en samenwerken met gecentraliseerde beurzen om accounts van misbruikers te bevriezen.</p>
<h2 id="h2-Markttrends20De20markt20daalt20over20het20algemeen20en20de20prestaties20van20MAGA20zijn20indrukwekkend156347"><a name="Markttrends: De markt daalt over het algemeen en de prestaties van MAGA zijn indrukwekkend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt daalt over het algemeen en de prestaties van MAGA zijn indrukwekkend</h2><p>BTC consolideert momenteel onder $67.000, wat erop wijst dat de markt mogelijk wacht op nieuwe katalysatoren.</p>
<p>ETH daalde onder de $3.500, wat wijst op een zwak sentiment op de markt. Het ETH ETF wordt verwacht deze zomer te worden goedgekeurd, wat mogelijk een belangrijke positieve factor wordt en aandacht verdient.</p>
<p>De meeste Altcoins zijn teruggekeerd naar hun prijzen van voor de CPI, wat wijst op een voorzichtige marktsentiment.</p>
<h3 id="h3-Macroeconomie280546"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>De Amerikaanse aandelenmarkt is volatiel. Hoewel de daling van de PPI-gegevens een kleine positieve ontwikkeling is, heeft dit de markt niet significant beïnvloed. Investeerders moeten blijven letten op CPI-gegevens en de beleidstrends van de Federal Reserve, aangezien deze factoren een grotere impact hebben op de markt.</p>
<h3 id="h3-Markt20Hotspots526217"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>CRV: De oprichter heeft meer dan $100 miljoen gestaked in CRV zendingen, wat ontevredenheid in de gemeenschap heeft veroorzaakt en heeft geleid tot een kortetermijndaling van 40% in de prijzen. Hoewel de meeste on-chain schulden zijn afbetaald, is de prijs niet significant hersteld, wat duidt op een gebrek aan marktvertrouwen.</p>
<p><strong>Meme sector:</strong><br>MAGA steeg met meer dan 20% binnen een dag, mogelijk vanwege 14 juni Trump’s verjaardag is, en de markt greep de kans om op te hypen. Het kan op korte termijn blijven stijgen, maar de volatiliteit is hoog.</p>
<p>BOME steeg met 15%, en het lanceerde contracten op Coinbase. Dit nieuws kan de prijs blijven stimuleren.</p>
<p>TON-ecosysteem: TON steeg met 10% binnen een dag en bereikte een nieuw historisch hoogtepunt. De TVL van het ecosysteem is meer dan $550 miljoen, wat ook een historisch hoogtepunt bereikt en een sterke marktvraag aantoont. TON presteert momenteel sterk en is geschikt voor middellange tot langetermijnbeleggingen, maar het is belangrijk om aandacht te besteden aan veranderingen in het marktsentiment.</p>
<p>Het huidige marktsentiment is behoorlijk complex, met BTC en ETH in belangrijke prijsbereiken, en de prestaties van Altcoin zijn gedifferentieerd. Macroeconomische gegevens zoals CPI en Fed-beleid blijven belangrijke beïnvloedende factoren. Wat betreft hete onderwerpen, de Meme coin sector vertoont aanzienlijke schommelingen en is geschikt voor kortetermijnhandel; TON presteert sterk en is geschikt voor middellange tot lange termijn vasthouden. Beleggers moeten flexibele aanpassingen maken op basis van hun eigen risicovoorkeuren en marktveranderingen.</p>
<h2 id="h2-Macro20Technologieaandelen20leiden20de20winsten20op20de20Nasdaq20en20SampP2050020De20Aziatische20markt20daalde20in20de20vroege20handelssessie20Japanse20yen20schommelt20voorafgaand20aan20de20beslissing20van20de20centrale20bank770761"><a name="Macro: Technologieaandelen leiden de winsten op de Nasdaq en S&amp;P 500; De Aziatische markt daalde in de vroege handelssessie; Japanse yen schommelt voorafgaand aan de beslissing van de centrale bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologieaandelen leiden de winsten op de Nasdaq en S&amp;P 500; De Aziatische markt daalde in de vroege handelssessie; Japanse yen schommelt voorafgaand aan de beslissing van de centrale bank</h2><p>Op 13 juni bereikten de S&amp;P 500 en NASDAQ-indexen nieuwe slotkoersen voor de vierde opeenvolgende handelsdag, terwijl technologieaandelen de algehele markt blijven stuwen. Vorige week steeg het aantal eerste aanvragen voor een werkloosheidsuitkering in de Verenigde Staten, en een ander rapport toonde een onverwachte daling van de producentenprijzen in mei, waardoor de marktverwachtingen voor de aankomende renteverlaging van de Federal Reserve verder toenamen.</p>
<p>Specifieke gegevens tonen aan dat de Dow Jones-index met 0,2% daalde, de S&amp;P 500-index met 0,2% steeg en de Nasdaq-index met 0,3% steeg. De technologie sector van de S&amp;P 500-index steeg met 1,4%, terwijl de semiconductor index met 1,5% steeg, beide bereikten historische slotkoersen.</p>
<p>Volgens de FedWatch tool van de Chicago Mercantile Exchange schatten financiële markten momenteel de kans op 60,5% dat de Federal Reserve in september de federal funds target rate met 25 basispunten zal verlagen.</p>
<p>Op 14 juni daalden Aziatische aandelenmarkten op vrijdag omdat de Federal Reserve de verwachtingen van renteverlagingen verlichtte nadat de Amerikaanse inflatiedata onder de verwachtingen uitkwamen, waardoor investeerders zich zorgen maakten over het vooruitzicht van Amerikaanse rentetarieven. Tegelijkertijd toonde de yen instabiliteit vóór de beleidsvergadering van de Bank of Japan.</p>
<p>Beïnvloed door havikachtige opmerkingen van de Federal Reserve deze week, zweeft de Amerikaanse dollar rond een maandhoogte, terwijl politieke onzekerheid in Europa blijft druk uitoefenen op de euro.</p>
<p>De MSCI Asia Pacific aandelenindex daalde met 0,48%. Ook de Chinese aandelenmarkt presteerde slecht, met een daling van 0,3% van de blue-chip aandelen en een daling van 0,79% van de Hang Seng Index in Hongkong. De Nikkei-index van Japan daalde licht met 0,03%, waarbij de yen in de vroege handel licht verzwakte tot 157,185 yen per dollar, omdat de markt verwachtte dat de Bank of Japan de ultralage rentetarieven ongewijzigd zou handhaven.</p>
<p>De Bank of Japan kan ultra-lage rentetarieven handhaven op zijn vergadering op vrijdag, maar overweegt of het zijn enorme balans moet beginnen te verkleinen om geleidelijk terug te trekken uit grootschalige monetair stimulerende beleidsmaatregelen. Vanwege zwakke consumptie en twijfels over of de Bank of Japan haar inflatiedoelstelling van 2% kan handhaven, staat de normalisatie van het ruime monetaire beleid voor uitdagingen.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen op vrijdag gedaald, maar wordt verwacht dat ze hun eerste wekelijkse stijging in vier weken zullen realiseren, omdat de markt de impact van de langetermijnrente in de Verenigde Staten en de sterke vooruitzichten voor ruwe olie en brandstofvraag dit jaar ueert. Brent ruwe oliefutures daalden met 0,62% tot $82,26 per vat, terwijl West Texas Intermediate (WTI) Amerikaanse ruwe oliefutures met 0,69% daalden tot $78,08 per vat.</p>
<p>Als gevolg van lager dan verwachte producentenprijsindex (PPI) rapporten daalde de goudprijs ten opzichte van de Amerikaanse dollar. De prijs van spotgoud daalde met 0,8% naar $2.303,15 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 enkel 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>