RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBkYWFsdCBvdmVyIGhldCBhbGdlbWVlbjsgQ3VydmUgQ0VPIHZlcmR1aWRlbGlqa3QgbWlzdmVyc3RhbmRlbiBtZXQgYmV0cmVra2luZyB0b3QgaGV0IFV3VSBMZW5kLWhhY2tpbmNpZGVudCBlbiBoZXQgdmVyYnJhbmRlbiB2YW4gQ1JW

2024-06-17, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/17185979301_12.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Curve20CEO20verduidelijkte20misverstanden20over20het20UwU20Lend20hackincident20en20CRVverbranding20Notcoin20kondigde20het20einde20van20de20airdrop20claim20aan20APE20MANTA20en20andere20tokens20zullen20volgende20week20grote20unlocks20ontvangen687630"><a name="Crypto Dagelijkse Samenvatting: Curve CEO verduidelijkte misverstanden over het UwU Lend hack-incident en CRV-verbranding; Notcoin kondigde het einde van de airdrop claim aan; APE, MANTA en andere tokens zullen volgende week grote unlocks ontvangen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Curve CEO verduidelijkte misverstanden over het UwU Lend hack-incident en CRV-verbranding; Notcoin kondigde het einde van de airdrop claim aan; APE, MANTA en andere tokens zullen volgende week grote unlocks ontvangen</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 Farside Investor-gegevens ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 14 juni nog steeds een uitstroom van $52,3 miljoen aan fondsen. Ondertussen had Fidelity Bitcoin spot ETF (FBTC) een instroom van $80,1 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $29 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) een instroom van $49 miljoen, en iShares Trust Bitcoin spot ETF (IBIT) een netto instroom van $1,5 miljoen.</p>
<p><strong>Curve CEO verduidelijkte misverstanden met betrekking tot het UwU Lend-hackincident en CRV-verbranding</strong><br>Michael Egorov, oprichter en CEO van Curve Finance (CRV), verduidelijkte het recente UwU Lend hackincident. Hij wees erop dat het incident geen betrekking had op enige achterpoortjes in Curve Finance.</p>
<p>Op maandag heeft een kwetsbaarheid in UwU Lend automatisch Egorov’s lening van $100 miljoen liquideerd vanuit meerdere overeenkomsten, waardoor de prijs van CRV-tokens met wel 30% daalde. Egorov legde uit: ‘Dit is geen kwetsbaarheid van Curve. Het is een kwetsbaarheid van UwU Lend, een enkel project.’ Hij stelde voor dat UwU Lend ‘alle contracten beoordeelt en samenwerkt met uitstekende beveiligingsauditors’ om verliezen te herstellen.</p>
<p>Voor de vervolgcompensatiemaatregelen voor dit incident stelde hij voor om 10% van de uitstaande CRV-tokens te verbranden om de tokenprijzen te herstellen naar het niveau van vóór het ong.</p>
<p><strong>Notcoin kondigde het einde aan van het airdrop-claimen, en niet-geclaimde tokens zullen worden gebruikt voor toekomstige ontwikkeling of verbranding</strong><br>Het Telegram-spelproject Notcoin heeft op het X-platform aangekondigd dat de airdropclaim is beëindigd. De meeste airdropped tokens zijn gedistribueerd en niet-geclaimde tokens zullen worden gebruikt voor toekomstige ontwikkeling. Sommige zullen worden verbrand.</p>
<p>Notcoin ($NOT) is een door de gemeenschap gedreven token dat een op Telegram gebaseerd spel is dat een ‘klik-om-te-verdienen’ mijnmechanisme gebruikt om gebruikers te betrekken bij het Web3-ecosysteem door boeiende interacties.</p>
<p>In eerste instantie kunnen gebruikers zich registreren en op de muntafbeelding ‘klikken’ om spelbeloningen te ontvangen, en het voltooien van verschillende taken en opdrachten kan ook extra beloningen en prijzen opleveren. Dit spel ontwikkelde zich snel, gevolgd door de geboorte van Notcoin-tokens en gebruikers die luchtdrops ontvingen. Het spel heeft een beoordelingssysteem van brons, zilver, goud en platina niveaus, waardoor actieve gebruikers meer beloningen kunnen ontvangen. Eerder was het Notcoin-saldo ook gestaked, wat resulteerde in een upgrade van het niveau en verhoogde beloningen.</p>
<p>Op dit moment heeft Notcoin 11,5 miljoen houders. Er zullen extra beloningen zijn voor spelers die de Gold en Platinum staking niveaus hebben bereikt.</p>
<p><strong>Het opmerkelijke token-ontgrendelingsevenement van volgende week:</strong> <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a>(APE): <a href="/price/apecoin-ape" target="_blank" class="blog_inner_link">ApeCoin</a> is de inheemse token van het Ape-ecosysteem van Yuga Labs en omvat de populaire Bored Ape Yacht Club (BAYC) NFT-serie. Op 17 juni zal het project meer dan 15 miljoen tokens ontgrendelen en deze verdelen onder de schatkist, oprichters, teamleden en bijdragers. Gewoonlijk daalt de prijs van APE na het ontgrendelen van veel tokens. Echter, de daling kan niet significant zijn vanwege de hernieuwde interesse in niet-fungibele tokens zoals BAYC.</p>
<p>-Ontgrendelingsdatum: 17 juni<br>-Ontgrendeld tokenaantal: 15,6 miljoen APE<br>-Huidige omloop: 627,8 miljoen APE</p>
<p>Manta Network (MANTA): Manta Network is een modulaire blockchain die gebruik maakt van zk-SNARK technologie om privacybescherming te bieden voor DeFi-toepassingen, waardoor privétransacties en interacties mogelijk zijn. Het Manta Network bestaat uit twee netwerken: Manta Pacific (het is een modulair L2-ecosysteem geschikt voor EVM native ZK-toepassingen en dApps) en Manta Atlantic (het is de snelste L1-blockchain op <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> en biedt zkSBT-functionaliteit). Op 18 juni zal de omloop van MANTA toenemen met 6,67 miljoen, en deze nieuw ontgrendelde tokens zullen worden verdeeld onder deelnemers voor openbare verkoop.</p>
<p>-Ontgrendelingsdatum: 18 juni<br>-Ontgrendelde tokens hoeveelheid: 6,67 miljoen MANTA<br>-Huidige circulerende aanbod: 325,3 miljoen MANTA</p>
<p>Pixels (PIXEL): Pixels is een multiplayer spel gebaseerd op de Ronin blockchain, waarbij PIXEL tokens worden gebruikt als in-game munten en community governance tools. PIXEL-houders kunnen NFT’s maken, items en VIP-passen kopen, zich aansluiten bij gilden en stemmen over projectontwikkeling. Op 19 juni worden er 54,38 miljoen PIXEL-tokens ontgrendeld en toegewezen aan consultants, projectfondsen en ecosysteembeloningen.</p>
<p>-Ontgrendelingsdatum: 19 juni<br>-Ontgrendelde tokenhoeveelheid: 54,38 miljoen PIXEL<br>-Huidige circulatie: 771 miljoen PIXEL</p>
<p>Space ID: Space ID is een universeel gedecentraliseerd identiteitsprotocol dat mensen, activa en dApps op verschillende blockchains met elkaar verbindt. Het stelt gebruikers in staat om een enkele domeinnaam te gebruiken om hun identiteiten in verschillende applicaties en netwerken te vertegenwoordigen. Op 22 juni zal het project 78,5 miljoen ID-tokens vrijgeven en deze toewijzen aan de Space ID Foundation en meerdere rondes van verkoopdeelnemers.</p>
<p>-Ontgrendeldatum: 22 juni<br>-Ontgrendelde hoeveelheid tokens: 78,5 miljoen ID<br>-Huidige circulatie: 430 miljoen ID</p>
<p>Bovendien worden binnenkort andere tokens ontgrendeld, waaronder Nym (NYM), <a href="/price/kadena-kda" rel="nofollow noopener noreferrer" target="_blank">Kadena</a> (KDA), Euler (EUL) en Pendle (PENDLE), met een totale waarde van meer dan $170 miljoen.</p>
<h2 id="h2-Markttrends20De20markt20daalt20over20het20algemeen20en20de20prestaties20van20MAGA20zijn20indrukwekkend964159"><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 de $67.000, wat aangeeft dat de markt misschien wacht op nieuwe prikkels.</p>
<p>ETH daalde onder $3.500, wat duidt op een zwak marktsentiment. De ETH ETF wordt verwacht deze zomer te worden goedgekeurd, wat mogelijk een belangrijke positieve factor zal zijn en aandacht verdient.</p>
<p>Altcoins: De meeste Altcoin prijzen zijn terugglen naar het niveau van vóór de publicatie van CPI-gegevens, wat wijst op een voorzichtige marktsentiment.</p>
<h3 id="h3-Macroeconomie483861"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Volatiliteit op de Amerikaanse aandelenmarkt: Hoewel de daling van de PPI-gegevens een kleine positieve invloed heeft gehad, heeft dit de markt niet significant beïnvloed. Beleggers moeten blijven letten op de CPI-gegevens en de beleidstrends van de Federal Reserve, omdat deze factoren een grotere impact hebben op de markt.</p>
<h3 id="h3-Markt20Hotspots706388"><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 aan CRV-schepen gestoken, wat ontevredenheid in de gemeenschap heeft veroorzaakt en heeft geleid tot een kortetermijndaling van 40% in de prijzen. Hoewel het de meeste van zijn on-chain schulden heeft afbetaald, is de prijs niet significant hersteld, wat wijst op een gebrek aan marktvertrouwen.</p>
<p>Meme sector: MAGA steeg tijdens de dag met meer dan 20%, mogelijk vanwege 14 juni als de verjaardag van Trump, en de markt greep de kans om opwinding te veroorzaken. Het kan op korte termijn blijven stijgen, maar de volatiliteit is hoog.</p>
<p>TON Ecosysteem: TON steeg met 10% binnen de dag en bereikte een nieuwe historische hoogte. De TVL van het ecosysteem heeft de $550 miljoen overschreden, ook een historisch hoogtepunt, wat wijst op een sterke marktvraag. TON presteert momenteel sterk en is geschikt voor middellange tot langetermijnbeleggingen, maar het is belangrijk om aandacht te besteden aan veranderingen in marktsentiment.</p>
<p>Het huidige marktsentiment is behoorlijk complex, met BTC en ETH in belangrijke prijsgebieden, en de prestaties van Altcoins zijn gedifferentieerd. Macroeconomische gegevens zoals CPI en het beleid van de Federal Reserve blijven belangrijke beïnvloedende factoren. Wat betreft hete onderwerpen, de Meme coin sector heeft aanzienlijke schommelingen en is geschikt voor kortetermijnhandel; TON presteert sterk en is geschikt voor middellange tot langetermijnbezit. Beleggers moeten flexibele aanpassingen maken op basis van hun risicovoorkeuren en marktveranderingen.</p>
<h2 id="h2-Macro20Technologieaandelen20leidden20de20winsten20met20Nasdaq20die20opeenvolgende20slotkoersen20bereikte20De20Aziatische20markt20verzwakt20over20het20algemeen723074"><a name="Macro: Technologieaandelen leidden de winsten, met Nasdaq die opeenvolgende slotkoersen bereikte; De Aziatische markt verzwakt over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologieaandelen leidden de winsten, met Nasdaq die opeenvolgende slotkoersen bereikte; De Aziatische markt verzwakt over het algemeen</h2><p>Op 14 juni bereikte de Nasdaq-index voor de vijfde opeenvolgende handelsdag een nieuwe slotkoers, gedreven door de stijging van Adobe en andere technologieaandelen, terwijl de S&amp;P 500-index en de Dow Jones-index licht daalden.</p>
<p>De S&amp;P 500-index heeft zijn vier opeenvolgende dagen van het bereiken van een nieuwe slotstand beëindigd, maar steeg deze week nog steeds meer dan 1%. De technologiesector steeg met 0,5% en bereikte een nieuwe slotstand. De communicatiedienstensector steeg met 0,6%, wat leidde tot winst in verschillende sectoren. Wat betreft specifieke indices, de Dow Jones-index daalde met 0,2%, de S&amp;P 500-index daalde met 0,04% en de Nasdaq-index steeg met 0,1%.</p>
<p>Fed-beleidsmakers verlaagden hun verwachting van drie renteverlagingen dit jaar naar één op woensdag. Een rapport dat vrijdag werd uitgebracht, toonde echter aan dat de initiële waarde van de Universiteit van Michigan Consumer Confidence Index voor juni daalde naar 65,6, ver onder de verwachtingen. De CPI-gegevens laten ook een afkoeling van de inflatie zien, wat kan leiden tot renteverlagingen.</p>
<p>Op 17 juni verzwakten de Aziatische aandelenmarkten over het algemeen, waren de economische gegevens van China ongelijk en verzwakte de politieke onzekerheid in Europa het risicobereidheid van investeerders, wat de euro verzwakte.</p>
<p>De blue-chip aandelen van China daalden met 0,2%. Hoewel de detailhandelsverkopen in mei met 3,7% stegen en de verwachtingen overtroffen, presteerden de industriële output en de investeringen in vaste activa slecht. Uit de gegevens blijkt dat de huizenprijzen in mei het snelst in tien jaar zijn gedaald, wat wijst op de aanhoudende druk op de vastgoedsector. De Nikkei-index in Japan daalde met 1,7% en investeerders moeten zes weken wachten om de details van de volgende aanscherpingsmaatregelen van de Bank of Japan te horen.</p>
<p>Deze week wordt verwacht dat de centrale banken van Australië, Noorwegen en het Verenigd Koninkrijk de rentetarieven ongewijzigd zullen houden tijdens de vergadering, maar vanwege de recente sterkte van de Zwitserse frank kan de Zwitserse centrale bank de rentetarieven verlagen.</p>
<p>De politieke onzekerheid in Frankrijk leidde ertoe dat de euro vrijdag daalde naar een viermaandsdieptepunt van 0,9505 tegen de Zwitserse frank, wat de mogelijkheid van een renteverlaging van 75% op de markt vergrootte. De wisselkoers van de euro/US dollar bleef op $1,0698, bereikte vorige week een dieptepunt van zes weken van $1,06678. De Amerikaanse dollar/yen versterkte lichtjes naar 157,52 yen nadat deze op een gegeven moment door de 158,00 yen brak als gevolg van de aankondiging van de Bank of Japan afgelopen vrijdag dat zij zouden beginnen met het verminderen van de aankopen van obligaties.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gedaald na een stijging van 4% vorige week als gevolg van verwachtingen van een sterkere vraag tijdens het piekrijseizoen in de Verenigde Staten. De prijs van Brent ruwe olie daalde met 17 cent naar $82,45 per vat, terwijl de prijs van Amerikaanse ruwe olie met 18 cent daalde naar $78,27 per vat.</p>
<p>De goudprijs bleef staan op $2.325 per ounce en steeg vorige week met 1,7%.</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 beleggingsaanbeveling.<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 zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>