RGFnZWxpamtzIG5pZXV3cyB8IEJsYWNrUm9jayBFdGhlcmV1bSBFVEYgc3RlbHQgZWVuIHZlcmdvZWRpbmcgdmFuIDAsMjUlIGluOyBIZXQgYmxvY2tjaGFpbi1pZGVudGl0ZWl0c3BsYXRmb3JtIEZyYWN0YWwgSUQgaGVlZnQgdGUgbWFrZW4gZ2VoYWQgbWV0IGVlbiBkYXRhbGVrOyBBZXRoaXIgbGFuY2VlcmRlIGVlbiBDb21tdW5pdHk

2024-07-18, 03:31

<p><img src="https://gimg2.gateimg.com/image/article/17212733371_15.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Fractal20ID20een20blockchainidentiteitsplatform20heeft20te20maken20gehad20met20een20gegevensinbreuk20BlackRock20Ethereum20ETF20heeft20een20vergoeding20van2002520ingesteld20Aethir20heeft20een20beloningsprogramma20van205020miljoen20voor20de20gemeenschap20gelanceerd101240"><a name="Crypto Daily Digest: Fractal ID, een blockchain-identiteitsplatform, heeft te maken gehad met een gegevensinbreuk; BlackRock Ethereum ETF heeft een vergoeding van 0,25% ingesteld; Aethir heeft een beloningsprogramma van $50 miljoen voor de gemeenschap gelanceerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Fractal ID, een blockchain-identiteitsplatform, heeft te maken gehad met een gegevensinbreuk; BlackRock <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF heeft een vergoeding van 0,25% ingesteld; Aethir heeft een beloningsprogramma van $50 miljoen voor de gemeenschap gelanceerd</h2><p>Eerst zullen we de handelsactiviteit van de onderzoeken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Volgens de gegevens van Farside Investor had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 17 juli een fondsuitstroom van $53,9 miljoen. Ondertussen ontving Fidelity Bitcoin Spot ETF (FBTC) een instroom van $2,8 miljoen, terwijl Bitwise Bitcoin Spot ETF (BITB) een uitstroom van $6 miljoen ontving.</p>
<p><strong>BlackRock heeft een vergoeding van 0,25% vastgesteld in de nieuwste herziene versie, en bedrijven bereiden zich voor om spot te lanceren. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETFs</strong></p>
<p>Vermogensbeheergigant BlackRock heeft de vergoeding voor zijn spot Ethereum-product vastgesteld op 0,25% en bedrijven hebben herziene formulieren ingediend vóór de verwachte lancering van het product volgende week. Volgens de herziene S-1-registratieverklaring die woensdag werd ingediend, verklaarde BlackRock dat het gedurende een bepaalde periode “geheel of gedeeltelijk” kan afzien van de vergoedingen en de vergoedingen voor de eerste $ 2,5 miljard aan activa binnen een jaar na notering kan verlagen tot 0,12%.</p>
<p>Andere bedrijven hebben ook hun respectieve tarieven aangekondigd: 21Shares heeft een vergoeding van 0,21% vastgesteld, die binnen zes maanden na de datum van notering van aandelen of tijdens de eerste periode van $500 miljoen wordt kwijtgescholden; De vergoeding voor Bitwise is 0,20%; De vergoeding van Grayscale is 2,5%, veel hoger dan andere uitgevers. De kosten van Invesco Galaxy bedragen 0,25%, VanEck 0,20% en Franklin Templeton 0,19%.</p>
<p>Meerdere bronnen hebben gemeld dat spot Ethereum ETF’s vanaf 23 juli kunnen beginnen met handelen. Eric Balchunas, senior analist ETF bij Bloomberg, verklaarde dat de SEC heeft gereageerd op het verzoek van de uitgever om de definitieve S-1 documenten (inclusief kosten) terug te sturen op woensdag en vanaf maandag na sluitingstijd in werking te laten treden, om de uitgifte op dinsdag 23 juli te vergemakkelijken.</p>
<p><strong>Blockchain-identiteitsplatform Fractal ID heeft te maken gehad met een gegevensinbreuk</strong></p>
<p>Op 17 juli kondigde het blockchain-identiteitsplatform Fractal ID aan dat het op 14 juli te maken kreeg met een gegevensinbreuk. De partners van Fractal zijn onder andere betalingssysteem <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a> Pay, gedecentraliseerde financiële applicatie Acala, persoonlijkheidsverificatieproject <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Veelhoek</a> ID, social media platform <a href="/price/lukso-lyxe" target="_blank" class="blog_inner_link">Lukso</a> en andere Web3-toepassingen. Fractal heeft in zijn verklaring niet gespecificeerd welke partners getroffen zijn door deze inbraak.</p>
<p>Fractal verklaarde dat deze kwetsbaarheid alleen invloed had op “ongeveer 0,5% van de Fractal ID-gebruikersgroep”. Volgens de mededeling “heeft een externe derde partij buiten Fractal ID ongeautoriseerd toegang gekregen tot het account van de operator en een API- uitgevoerd dat begon met het benaderen van de persoonlijke gegevens van de gebruiker om 5:14 uur UTC-tijd.” Nadat het team deze kwetsbaarheid had opgemerkt, “heeft het actie ondernomen om de aanvaller uit het systeem uit te loggen vóór 7:29 uur UTC-tijd.” Daarom lijkt de aanval plaatsgevonden te hebben binnen 2 uur en 14 minuten.</p>
<p>In het bericht staat dat slechts een beperkte hoeveelheid accountgegevens wordt opgeslagen in de accounts van deze specifieke operator, die slechts 0,5% van het totale gebruikersbestand van Fractal uitmaken. Mogelijke gelekte gegevens zijn onder meer namen, e-mailadressen, portemonnee-adressen, telefoonnummers, fysieke adressen, afbeeldingen van geüploade bestanden en foto’s. Fractal beweert dat deze inbraak geen invloed had op het systeem of product van de klant, aangezien de inbraak “alleen plaatsvond in de [Fractal] omgeving”. Toch moeten getroffen gebruikers op hun hoede zijn voor ongevraagde communicatie die om meer persoonlijke informatie vraagt.</p>
<p><strong>Aethir lanceerde een beloningsprogramma voor de gemeenschap ter waarde van $50 miljoen en heeft de token-swap met io.net opgeschort.</strong></p>
<p>Volgens officiële bronnen heeft Aethir aangekondigd dat de eerder overeengekomen $50 miljoen token-uitwisselingsprogramma met io.net is opgeschort. De Aethir Foundation heeft besloten om een gemeenschapsbeloningsprogramma te lanceren, waarbij $50 miljoen aan ATH-tokens die oorspronkelijk waren toegewezen voor uitwisseling, worden verdeeld onder loyale en actieve deelnemers van het Aethir-netwerk, als erkenning voor de waardevolle bijdragen van de Aethir-gemeenschap en om mensen verder te stimuleren om deel te blijven nemen aan het Aethir-ecosysteem.</p>
<p>De toewijzing van dit plan is als volgt:</p>
<p>Beloning voor Checker Node License-houders: ATH-tokens ter waarde van $20 miljoen worden verdeeld onder Checker Node License-houders. Iedereen komt in aanmerking om het minimale aantal ATH’s te ontvangen. Voor houders die minimaal 2.500 ATH hebben geïnvesteerd in elke Checker License en degenen die sinds TGE hebben geïnvesteerd, worden extra bonussen toegekend. Aethir zal dagelijks snapshots maken om de geschiktheid te bepalen, waarbij de laatste snapshot plaatsvindt op 23 juli 2024.</p>
<p>Toename van de inkomsten van het ATH-AI-stakingspool: De resterende $30 miljoen aan ATH-tokens zal worden toegewezen aan het ATH-AI-stakingspool binnen 24 weken om de inkomsten te verhogen en de ontwikkeling van kunstmatige intelligentie-toepassingen op het Aethir-netwerk te ondersteunen.</p>
<p>Aethir verklaarde dat het $50 miljoen community beloningsprogramma een belangrijke mijlpaal is naar de gedecentraliseerde toekomst van cloud computing. Door de middelen die oorspronkelijk gebruikt werden voor de io.net token uitwisseling te herzien, kan de groei en ontwikkeling van het Aethir ecosysteem versneld worden.</p>
<h2 id="h2-Markttrends386170"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC raakte gisteren kortstondig $66.000 en zakte weer terug, consolideert momenteel rond $64.500. De spot ETF blijft $57 miljoen instromen (exclusief IBTC-gegevens voor nu).</p>
<p>ETH daalde nadat het door $3.500 heen brak en past momenteel aan rond $3.420.</p>
<p>Altcoins volgden de algemene markt neerwaarts.</p>
<h3 id="h3-Gegevensindicatoren300052"><a name="Gegevensindicatoren:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren:</h3><p>Vandaag staat de AHR999-index op 0,85, wat aangeeft dat de markt de bodemzone heeft overschreden.</p>
<p>De Fear &amp; Greed Index staat op 61, wat duidt op een lichte verlichting van de markt hebzucht in vergelijking met gisteren.</p>
<h3 id="h3-Macroeconomie641183"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt hebben geschommeld, waarbij de Nasdaq met 2,77% is gedaald, voornamelijk als gevolg van de scherpe daling van de aandelen van Apple en Nvidia. Fed’s Williams gaf aan dat de Fed van plan is de rente te verlagen, maar nog niet klaar is.</p>
<h3 id="h3-Markt20Hotspots887109"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Ethereum Staking Sector:</strong><br>LDO, RPL, ETHFI en andere rebounds. SEC-commissarissen suggereren heroverweging van Ethereum ETF’s die ‘staking’ bevatten.</p>
<p><strong>GameFi Sector:</strong><br>BNX, ALICE, DAR en anderen zijn gestegen. Beïnvloed door het BNX-vernietigingsvoorstel is BNX deze maand bijna 200% gestegen. De GameFi-sector heeft gemiddeld gepresteerd in deze marktronde, terwijl andere tokens tekenen van achteruitgang hebben laten zien.</p>
<p><strong>Meme Sector:</strong><br>PEIPEI en NUB blijven stijgen en de volledig omlopende Meme-munt presteert uitstekend onder sterke controle van market makers. Bovendien, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> On-chain kat Meme coin MANEKI heeft officieel aangekondigd dat het eerste loterijkaartspel vanavond om 22:00 uur zal worden gelanceerd, met prijzen waaronder Cybertruck, Apple computers, drones en meer. Op dit moment is er geen duidelijke prijsreactie op de markt.</p>
<h3 id="h3-Samenvatting218732"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h3><p>De huidige markt bevindt zich in een algemene aanpassingsfase, waarbij BTC en ETH consolideren op hoge niveaus en Altcoins over het algemeen een terugval ervaren. Ondanks de onzekerheid in de macro-economische omgeving hebben de Ethereum-stakingsector en de GameFi-sector activiteit getoond, aangewakkerd door specifiek nieuws. De Meme-sector blijft versterken onder de omstandigheden van volledige circulatie en hoge controle. Beleggers moeten zich richten op macro-economische trends en veranderingen in marktsentiment om tijdig hun beleggingsstrategieën aan te passen.</p>
<h2 id="h2-Macro20Handelsspanningen20intensiveren20Amerikaanse20aandelen20dalen20Aziatische20aandelenmarkten20vallen20Japanse20yen20stijgt522100"><a name="Macro: Handelsspanningen intensiveren, Amerikaanse aandelen dalen, Aziatische aandelenmarkten vallen, Japanse yen stijgt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Handelsspanningen intensiveren, Amerikaanse aandelen dalen, Aziatische aandelenmarkten vallen, Japanse yen stijgt</h2><p>Op 17 juli daalden de S&amp;P 500-index en de Nasdaq-index sterk op woensdag, terwijl microchip-aandelen kelderden te midden van de mogelijke escalatie van het handelsconflict tussen de Verenigde Staten en China, waardoor de voortdurende uitstroom van grote technologieaandelen werd verergerd. De regering-Biden overweegt ernstige handelsbeperkingen op te leggen aan China, waardoor microchip-aandelen met 6,8% dalen, wat de grootste daling op één dag markeert in de Philadelphia Stock Exchange Semiconductor Index sinds maart 2020.</p>
<p>Indexprestaties: de Dow Jones Industrial Average steeg met 0,59%; de S&amp;P 500-index daalde met 1,39%; de Nasdaq-index daalde met 2,77%.</p>
<p>De momentum aandelen van de ‘Big Seven’, geleid door Nvidia, Apple, enz., ondervonden een terugval, waardoor de Nasdaq-index met 2,8% en de benchmark S&amp;P 500-index met 1,4% daalden. De Dow Jones Industrial Average loopt dit jaar achter op de andere twee indices, maar heeft de afgelopen dagen een lichte stijging behouden en heeft voor de derde keer op rij een nieuw recordhoogte van de slotkoers bereikt.</p>
<p>De Russell 2000 Index voor kleine kapitalisatie steeg met 11,5% in de afgelopen vijf handelsdagen en beëindigde zijn langste opwaartse trend in meer dan vier jaar, omdat beleggers opnieuw interesse toonden in meer ondergewaardeerde aandelen en sectoren op de aandelenmarkt.</p>
<p>De volatiliteitsindex van de Chicago Board Options Exchange bereikte het hoogste niveau in zes weken, wat aangeeft dat de angst van beleggers toeneemt.</p>
<p>Een ander rapport toont aan dat de groeisnelheid van industriële productie in juni twee keer zo hoog was als verwacht. Deze gegevens zijn in overeenstemming met recente rapporten die aangeven dat ondanks tekenen van zwakte in de Amerikaanse economie, haar veerkracht de Federal Reserve zal helpen de inflatie te verlagen naar haar streefcijfer van 2% zonder de economie te laten krimpen.</p>
<p>Het Beige Book dat door de Federal Reserve op woensdag is uitgebracht, toonde aan dat de economische activiteit in de VS matig is gegroeid van eind mei tot begin juli, maar er zijn tekenen dat de arbeidsmarkt zwak blijft.</p>
<p>Volgens de FedWatch-tool van de Chicago Mercantile Exchange verwachten financiële markten een kans van 93,5% dat de Federal Reserve in september de rentetarieven zal verlagen.</p>
<p><strong>Handelsspanningen nemen toe, Aziatische aandelenmarkten dalen, Japanse yen stijgt</strong></p>
<p>Op 18 juli daalden Aziatische aandelenmarkten op donderdag, geleid door chip aandelen, omdat investeerders zich zorgen maakten over de mogelijkheid van toenemende handelsspanningen tussen de Verenigde Staten en China, terwijl de Japanse yen steeg naar een zes weken hoogtepunt na de vermeende interventie van Tokio vorige week.</p>
<p>Als gevolg van de verklaringen van functionarissen van de Federal Reserve die de mogelijkheid van een renteverlaging in september vergroten, zweeft de wisselkoers van de Amerikaanse dollar tegen een mandje valuta rond het laagste niveau in vier maanden, en blijven de goudprijzen in de buurt van historische hoogtepunten.</p>
<p>De MSCI Asia Pacific aandelenindex daalde met 0,57%; Zuid-Koreaanse aandelen gedomineerd door technologieaandelen daalden bijna 1%; De Nikkei-index in Japan daalde met 2%. Als gevolg van investeerders die wachten op nieuws over de leiderschapsvergadering, ondervond ook de Chinese aandelenmarkt een daling, waarbij de Shanghai Composite Index met 0,4% daalde en de blue chip CSI 300 Index met 0,5% daalde.</p>
<p>Op het gebied van de valutamarkt heeft de Amerikaanse dollar te kampen met moeilijkheden, waarbij de wisselkoers van de euro/dollar stabiliseert op $1.09385, dicht bij het vier maanden oude hoogtepunt dat op woensdag werd bereikt. De meest recente wisselkoers van het pond tegenover de Amerikaanse dollar is $1.30065, dicht bij het hoogtepunt van een jaar geleden dat werd bereikt op de vorige handelsdag.</p>
<p>De grondstoffenmarkt zag donderdag een lichte stijging van de olieprijzen, gedreven door de onverwachte wekelijkse daling van de Amerikaanse voorraden ruwe olie. Brent ruwe olie futures stegen met 0,2% tot $85,21 per vat, terwijl Amerikaanse West Texas Intermediate (WTI) futures met 0,4% stegen tot $83,16 per vat.</p>
<p>De goudprijs steeg met 0,18% naar $2.462 per ounce, iets lager dan het historische hoogtepunt van woensdag van $2.483,60.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herdrukken van het artikel is 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>