RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZXJzdGVsZGUgYWFuemllbmxpamssIG1ldCBHQlRDLWthcGl0YWFsaW5zdHJvb20gdmFuICQ2M007IFVuaXN3YXAtQ0VPIHVpdHRlIHN0YW5kcHVudCBvdmVyIHRva2VuYWxsb2NhdGllOyBHZWJydWlrZXIgdmVybG9vciAkNzFNIGFhbiBXQlRDIGFscyBnZXZvbGcgdmFuIGVlbiBhZHJlc3Zlcmd

2024-05-06, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17149667551_2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20kapitaalinstroom20van20GBTC20op20vrijdag20bedroeg206320miljoen20CEO20van20Uniswap20heeft20zijn20visie20geuit20over20tokentoewijzing20Gebruiker20verloor207120miljoen20aan20WBTC20als20gevolg20van20een20adresvergiftigingsaanval735119"><a name="Crypto Dagelijkse Samenvatting: De kapitaalinstroom van GBTC op vrijdag bedroeg 63 miljoen; CEO van Uniswap heeft zijn visie geuit over token-toewijzing; Gebruiker verloor $71 miljoen aan WBTC als gevolg van een adresvergiftigingsaanval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De kapitaalinstroom van GBTC op vrijdag bedroeg 63 miljoen; CEO van <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> heeft zijn visie geuit over token-toewijzing; Gebruiker verloor $71 miljoen aan WBTC als gevolg van een adresvergiftigingsaanval</h2><p>Allereerst gaan we de handelsactiviteiten van nader bekijken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ondervonden Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 3 mei een uitstroom van $63 miljoen aan fondsen; Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $102,6 miljoen, de instroom van Bitwise Bitcoin spot ETF (BITB) $33,5 miljoen, en de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) was $28,1 miljoen.</p>
<p>Het is vermeldenswaard dat de GBTC-spot Bitcoin ETF-fondsen 78 dagen van continue uitstroom hebben beëindigd. Sinds de Amerikaanse spot Bitcoin ETF op 11 januari begon te handelen, is de cumulatieve uitstroom van fondsen van GBTC tot en met 2 mei meer dan $17,5 miljard geweest. Het fonds met hogere kosten genereerde echter plotseling een instroom van $63 miljoen op vrijdag.</p>
<p>Onlangs kondigde EigenLayer, een netwerk voor herstakingsactiviteiten, een airdrop aan, maar veel gebruikers werden uitgesloten. Ze bekritiseerden hevig de verklaring die werd uitgegeven door het herstakingsprotocol, waarin de niet-overdraagbare tokenstructuur, strikte geografische beperkingen en aanzienlijk kortere opnameperiode werden benadrukt. Als reactie op deze twijfels heeft EigenLayer na de eerste airdrop 28 miljoen EIGEN-tokens verdeeld over meer dan 280.000 portefeuilles.</p>
<p>Vanwege de bezorgdheid van de cryptogemeenschap over de transparantie en eerlijkheid van de tokentoewijzing van EigenLayer, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Oprichter en CEO Hayden Adams heeft zijn mening geuit over ethische overwegingen voor effectieve tokenallocatie. Een paar dagen geleden deelde Adams in een artikel zijn visie op het morele vraagstuk van tokenallocatie, waarbij hij benadrukte dat hij het had over tokens in plaats van punten. Vervolgens bekritiseerde hij het creëren van ambiguïteit in het proces van tokenverdeling om de participatie-indicatoren te overdrijven.</p>
<p>Als senior utive van Uniswap is Adams sterk gekant tegen tokens met een lage doorvoer, omdat hij gelooft dat ze kwaadaardig zijn en zijn meest gehate. Hij gelooft dat het project tokens effectief kan toewijzen zonder afhankelijk te zijn van beurzen of marktmakers. Hij verklaarde dat de ideale aanpak is om tokens openbaar te distribueren om ware prijsontdekking op gedecentraliseerde beurzen (DEX) te bereiken.</p>
<p>Adams bekritiseerde ook het gebruik van eenheidspatronen om een overmatige tokenvoorraad te creëren en wees erop dat deze aanpak onnodig is. Bovendien stelt hij voor dat tokenverdelers niet te conservatief moeten zijn en het gebruik van de meeste tokens voor distributie moeten aanmoedigen.</p>
<p>Samengevat dringen Uniswap-utives er bij token-uitgevers op aan om rekening te houden met en transparant te zijn over hun projecten. Voor UNI-tokens benadrukt hij het belang van het uitbrengen van een token waar ze trots op kunnen zijn en steunen om vragen binnen de cryptogemeenschap te vermijden.</p>
<p>Iemand heeft meer dan $71 miljoen aan WBTC verloren in een schijnbare adres vergiftigingsaanval. WBTC is een ERC-token die 1:1 gekoppeld is aan Bitcoin en kan worden gebruikt in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosysteem.</p>
<p>Volgens de on-chain overdracht van de Etherscan blockchain-browser heeft dit slachtoffer 1.155 WBTC ($71,1 miljoen) overgedragen aan de vermoedelijke aanvaller. Daarna werd het adres van de hacker gemarkeerd als “nep” en “phishing” op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain-browser Etherscan.</p>
<p>De zogenaamde adresvergiftigingsaanval verwijst naar hackers die virtuele adresdiensten of adresmijnbouw gebruiken om portefeuilleadressen te construeren die lijken op die van de slachtoffers en een grote hoeveelheid transactiespam naar de slachtoffers sturen. Als het slachtoffer per ongeluk het valse adres van de hacker kopieert, zullen ze in plaats van zichzelf geld overmaken naar de hacker.</p>
<p>Voor gebruikers kan het kopiëren van adressen van transacties die al zijn gedaan in hun portemonnee betrouwbaarder zijn bij het overmaken van cryptocurrency om verschillende oplichting te voorkomen.</p>
<h2 id="h2-Markttrends20BTC20is20aanzienlijk20hersteld20begint20het20Altcoinseizoen20binnenkort220348"><a name="Markttrends: BTC is aanzienlijk hersteld, begint het Altcoin-seizoen binnenkort?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC is aanzienlijk hersteld, begint het Altcoin-seizoen binnenkort?</h2><p>Vorige week, na een aanzienlijke daling, herstelden de BTC-prijzen sterk van een dieptepunt van $56.500 tot ongeveer $64.500, en de markt vertoont momenteel een grote volatiliteit. Met het herstel van Bitcoin heeft de Altcoin-markt ook een grootschalige stijging doorgemaakt, vooral met de uitstekende prestaties van AI-conceptvaluta’s. Vanuit historisch perspectief veroorzaakt een aanzienlijke daling van Bitcoin vaak een zogenaamd ‘Altcoin-seizoen’.</p>
<p>Met betrekking tot de macro-economie heeft de Amerikaanse aandelenmarkt onlangs een sterke opwaartse trend laten zien, terwijl de Amerikaanse dollarkoers relatief is gedaald. De beter dan verwachte gegevens over de werkgelegenheid buiten de agrarische sector ondersteunen de verwachting van de markt dat de Federal Reserve dit jaar eerder de rente kan verlagen. Momenteel verwacht de markt over het algemeen dat de renteverlaging wordt vervroegd van november naar september.</p>
<h3 id="h3-Markt20Hotspots735168"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>AI-conceptmunten zijn gestegen: AR, ARKM, WLD, RNDR, AKT, ALEPH en andere AI-conceptvaluta’s zijn de laatste tijd aanzienlijk toegenomen. De belangrijkste hete onderwerpen op de markt zijn nog steeds gericht op de concepten van AI en Meme. Met de aanstaande ChatGPT 5 en de ontwikkelaarsconferentie van Apple is de marktinteresse in AI-conceptvaluta’s aanzienlijk toegenomen, en sommige AI-concepttokens hebben hun hoogtepunten voor de daling weer bereikt.</p>
<p>De prestaties van gevestigde munten zijn sterk: Teller (TRB) en Frontier (FRONT) zijn onlangs gestegen, waarbij TRB in de afgelopen drie dagen met meer dan 100% is gestegen. Naarmate de markt geleidelijk stabiliseert, zijn deze oude munten met vitale marktactiviteiten opnieuw het middelpunt van de aandacht van investeerders.</p>
<p>Toekomstige risico’s om op te focussen: STRK is van plan volgende week $100 miljoen aan tokens vrij te geven. Dergelijke gebeurtenissen kunnen enorme verkoopdruk van vroege investeerders met zich meebrengen; hoewel de marktwaarde kan stijgen, kunnen de tokenprijzen onderdrukt worden, en investeerders moeten deze trend nauwlettend in de gaten houden.</p>
<p>De huidige cryptomarkt vertoont tekenen van herstel, met name in de AI- en Meme-sectoren. Echter, met de vrijgave van belangrijke gebeurtenissen en gegevens kan de marktvolatiliteit toenemen. Investeerders moeten waakzaam blijven, aandacht besteden aan macro-economische veranderingen, technologische ontwikkelingen en gebeurtenissen die verband houden met het ontgrendelen van tokens, en prompt hun strategieën aanpassen om met de voortdurend veranderende marktomgeving om te gaan.</p>
<h2 id="h2-Macro20De20Fed20brengt20een20duifachtige20verklaring20uit20arbeidsrapporten20tonen20optimisme20wereldwijde20markten20worden20gestimuleerd248103"><a name="Macro: De Fed brengt een duifachtige verklaring uit, arbeidsrapporten tonen optimisme, wereldwijde markten worden gestimuleerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Fed brengt een duifachtige verklaring uit, arbeidsrapporten tonen optimisme, wereldwijde markten worden gestimuleerd</h2><p>Op vrijdag sloot de aandelenmarkt van Wall Street hoger, voornamelijk vanwege een lager dan verwacht werkgelegenheidsrapport dat de renteverlaging van de Federal Reserve ondersteunt en bewijs levert van de veerkracht van de Amerikaanse economie. De drie belangrijkste Amerikaanse aandelenindexen zijn allemaal aanzienlijk gestegen, geleid door de Nasdaq-index, gedomineerd door technologieaandelen.</p>
<p>De specifieke indexprestaties zijn als volgt: de Dow Jones-index steeg met 1,18%, de Standard &amp; Poor’s-index steeg met 1,26% en de Nasdaq-index steeg met 1,99%.</p>
<p>Federal Reserve-voorzitter Jerome Powell heeft een meer dovish verklaring afgelegd dan verwacht na de rentebeslissing van woensdag, wat de markt heeft gestimuleerd. Ondertussen toont het arbeidsrapport van het Ministerie van Arbeid aan dat nieuwe banen in de Verenigde Staten lager zijn dan verwacht, de werkloosheid stijgt en de loongroei onverwacht vertraagt. Dit rapport kan de zwakke plek van de Federal Reserve hebben geraakt en tekenen hebben gegeven van een zwakke arbeidsmarkt, waarvan Powell gelooft dat deze nodig is om een duurzaam dalend pad voor inflatie te handhaven.</p>
<p>Dit rapport verzekert ook de gezondheid van de Amerikaanse economie. Dit heeft investeerders aangespoord om hun weddenschappen te verhogen dat de Federal Reserve in september zijn eerste renteverlaging zal doorvoeren.</p>
<p>Het eerste kwartaal van het financiële rapportageseizoen staat op het punt om zijn laatste fase in te gaan, en tot vrijdagochtend hebben 397 bedrijven in de S&amp;P 500 index hun financiële rapporten vrijgegeven. Volgens gegevens van LSEG heeft 77% van de bedrijven aangekondigd beter te presteren dan verwacht.</p>
<p>Een representatief voorbeeld is dat Apple een recordbrekend $110 miljard aandeleninkoopplan heeft aangekondigd, dat de kwartaalverwachtingen overtrof en leidde tot een stijging van 6,0% in de aandelenkoers. Het biotechnologiebedrijf Anjin zag zijn aandelenkoers ook stijgen met 11,8% vanwege de bemoedigende midtermgegevens en de resultaten van het eerste kwartaal van zijn experimentele afslankmiddel MariTide.</p>
<p>Aziatische aandelenmarkten stegen op maandag omdat de markt opnieuw inzet dat de Federal Reserve dit jaar mogelijk de rente zal verlagen. Bovendien verzwakte de Japanse yen iets aan het begin van deze week na vorige week scherp te zijn gestegen vanwege vermoedelijke interventie van Tokyo.</p>
<p>De Amerikaanse dollar bleef stabiel nadat de arbeidsgegevens van het Ministerie van Arbeid een economische vertraging lieten zien, wat verdere ondersteuning biedt voor de verwachting dat de Federal Reserve dit jaar twee renteverlagingen kan doorvoeren. De Japanse yen boekte vorige week de sterkste stijging in meer dan 17 maanden.</p>
<p>Vorige week was de Japanse markt gesloten vanwege een feestdag en was de Chinese markt drie dagen gesloten. Maar nadat de gegevens een vertraging in de Amerikaanse arbeidsmarkt lieten zien, bevestigde voorzitter Jerome Powell van de Federal Reserve het soepele beleid van de centrale bank. De interventie van Japan deed de yen stijgen, de Amerikaanse dollar daalde en de offshore yuan steeg lichtjes.</p>
<p>De gegevens die op vrijdag zijn vrijgegeven, toonden aan dat de vertraging in de groei van de werkgelegenheid in de Verenigde Staten in april de verwachtingen overtrof, waarbij de jaarlijkse loongroei voor het eerst in bijna drie jaar onder de 4,0% daalde. Deze tekenen hebben geleid tot <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de mogelijkheid van een ‘zachte herstel’ door de Federal Reserve.</p>
<p>Uiteindelijk handhaafde de Federal Reserve aan het einde van de tweedaagse monetair beleidsvergadering de ongewijzigde rentetarieven. Het gaf echter aan dat het nog steeds neigde naar een laatste renteverlaging, ook al kan het langer duren dan aanvankelijk verwacht.</p>
<p>Op het gebied van grondstoffen steeg de Brent ruwe olie futures met 0,3% naar $83,21 per vat, terwijl de Amerikaanse ruwe olie futures ook licht stegen met 0,35% naar $78,39 per vat.</p>
<p>De goudprijzen stegen met 0,2% tot $2.307,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 alleen 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 zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>