RGFnZWxpamtzIG5pZXV3cyB8IEVpZ2VubGF5ZXIgYnJlbmd0IEVJR0VOLXRva2VuIHVpdDsgSG9uZyBLb25nIGxhbmNlZXJ0IG9mZmljaWVlbCBoZXQgZWVyc3RlIFNwb3QgQml0Y29pbiwgRXRoZXJldW0gRVRGIGluIEF6acOrOyBNZWVyIGRhbiA1MCUgdmFuIGRlIFJ1bmVzIGluIGhldCByb29kLCBpbiB2cmFhZyBnZXN0ZWxk

2024-04-30, 05:24

<p><img src="https://gimg2.gateimg.com/image/article/171445847230.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Eigenlayer20brengt20EIGEN20Whitepaper20uit20maar20geen20airdrops20naar20Amerikaanse20gebruikers20Hong20Kong20lanceert20officieel20het20eerste20Spot20Bitcoin20Ethereum20ETF20van20Azi20Meer20dan205020procent20van20de20Runes20in20het20rood20Rune20Protocol20in20twijfel433300"><a name="Crypto Dagelijkse Samenvatting: Eigenlayer brengt EIGEN Whitepaper uit, maar geen airdrops naar Amerikaanse gebruikers; Hong Kong lanceert officieel het eerste Spot Bitcoin, Ethereum ETF van Azië; Meer dan 50 procent van de Runes in het rood, Rune Protocol in twijfel." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Eigenlayer brengt EIGEN Whitepaper uit, maar geen airdrops naar Amerikaanse gebruikers; Hong Kong lanceert officieel het eerste Spot Bitcoin, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF van Azië; Meer dan 50 procent van de Runes in het rood, Rune Protocol in twijfel.</h2><p>Laten we eens kijken naar de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Eerst de ETF’s. Volgens Farside Investor-gegevens zag de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 29 april voortdurende uitstroom van $24,7 miljoen; ondertussen zagen de Fidelity Bitcoin Spot ETF (FBTC) uitstroom van $6,9 miljoen, terwijl de Bitwise Bitcoin Spot ETF (BITB) instroom van 29 miljoen zag, en ARK 21Shares Bitcoin Spot ETF (ARKB) uitstroom van $31,3 miljoen.</p>
<p>April bleek een moeilijke maand te zijn voor spot bitcoin ETF’s. Voorheen was Grayscale Trust de drijvende kracht achter kapitaalvlucht uit ETF’s, maar we beginnen ook geld uit nieuw gelanceerde ETF’s te zien stromen. Over het algemeen zijn de nieuwe ETF’s echter succesvol gebleven.</p>
<p>Eigenlayer, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het restaking-platform heeft op 29 april een whitepaper uitgebracht voor zijn voorgestelde nieuwe token, EIGEN. Volgens de whitepaper zal de EIGEN-token worden gebruikt voor toepassingen die afhankelijk zijn van intersubjectieve overeenkomsten, zoals voorspellingsmarkten, opslagdiensten en gaming virtuele machines. De binnenkort aan te kondigen airdrop zou echter bepaalde rechtsgebieden uitsluiten, zoals de VS en Canada.</p>
<p>Gestaked ETH op Ethereum kan opnieuw worden gestaked naar Eigenlayer en extra beloningen verdienen door transacties op beide netwerken te verifiëren. De oplossing wordt door ontwikkelaars beschouwd als veiliger dan het gebruik van aparte tokens, omdat het Eigenlayer in staat stelt de beveiliging van Ethereum te erven zonder de noodzaak om een vertrouwensnetwerk vanaf het begin op te bouwen.</p>
<p>Het primaire gebruik van EIGEN-tokens is het vormen van consensus rond off-chain maar gemakkelijk te verifiëren gegevens, zoals het bepalen of iemand gegevens adequaat heeft opgeslagen. Volgens het nieuwe whitepaper blijft gestake ETH worden gebruikt om consensus te vormen rond gegevens die on-chain kunnen worden geverifieerd, zoals de geldigheid van een transactie. Volgens het paper van Eigenlayer is vijf procent van de totale voorraad EIGEN toegewezen aan huidige gebruikers die ETH opnieuw hebben toegezegd via het netwerk, wat is vastgelegd op 15 maart. Het team heeft nog niet aangekondigd wanneer het tweede seizoen zal eindigen.</p>
<p>Ondanks meldingen dat het Eigenlayer-team zich voorbereidt om nieuwe tokens aan gebruikers uit te delen, is geconstateerd dat de webpagina niet toegankelijk is vanaf Amerikaanse IP-adressen of sommige VPN-serveradressen in Europa, wat erop wijst dat de VS, Canada en verschillende Afrikaanse en Aziatische landen niet zullen deelnemen aan de airdrop.</p>
<p>Zes spot bitcoin- en ethereum-beursgenoteerde fondsen werden vandaag officieel genoteerd aan de Hong Kong Stock Exchange, waarmee ze de eerste spot cryptocurrency ETF’s zijn die in Azië worden genoteerd.</p>
<p>Ze omvatten Bosera HashKey Bitcoin ETF (3008.HK), Bosera HashKey Ethereum ETF (3009.HK), Huaxia Bitcoin ETF (3042.HK), Huaxia Ethereum ETF (3046.HK), Harvest Bitcoin Spot ETF (3439.HK) en Harvest Ethereum Spot ETF (3179.HK).</p>
<p>Eerder heeft Hong Kong een aantal spot Bitcoin ETF’s en spot Ethereum ETF’s goedgekeurd, beheerd door Huaxia Funds, Harvest Global, Bosera en HashKey. De notering van de eerste spot cryptocurrency ETF’s van Azië zal de productdiversiteit en liquiditeit van HKEx verder verbeteren, zei Brian Roberts, hoofd van de afdeling productontwikkeling voor aandelen bij de beurs, in een verklaring.</p>
<p>Deze spot cryptocurrency ETF’s zijn niet alleen open voor Hong Kongse beleggers, maar ook voor gekwalificeerde beleggers buiten Hong Kong, hoewel Chinese beleggers op het vasteland nog steeds beperkt zijn.</p>
<p>De lancering van Runes heeft enorme opwinding veroorzaakt over het potentieel van memecoin, en biedt ook nieuwe functionaliteit voor het Bitcoin-netwerk. Runes kan de functionaliteit van de Bitcoin-blockchain uitbreiden, waardoor gebruikers een breed scala aan real-world assets kunnen tokeniseren. Dit opent nieuwe mogelijkheden voor DeFi-apps en andere gebruiksglen in het Bitcoin-ecosysteem.</p>
<p>Ondanks de aanvankelijke enthousiasme heeft Runes aanzienlijke kritiek gekregen vanwege het verhogen van bitcoin transactiekosten en het niet winstgevend zijn voor de meeste beleggers. Op 29 april was het aantal top 50 Runes-houders gemiddeld met 30 procent gedaald, waarbij tweederde van hen geld verloor.</p>
<p>Voorstanders zeggen dat het nog te vroeg is om pessimistisch te zijn over Runes. Ze geloven dat naarmate ontwikkelaars het protocol blijven verbeteren en meer substantiële functionaliteit bieden, Runes in staat zal zijn om de handelservaring te verbeteren en breder te worden gebruikt in het Bitcoin-ecosysteem. Als zodanig kijken ze uit naar het potentieel van Runes in de toekomst.</p>
<h2 id="h2-Markttrends20Cryptomarkten20vernauwen20Eigenlayer20klaar20om20tokens20uit20te20geven19954"><a name="Markttrends: Crypto-markten vernauwen; Eigenlayer klaar om tokens uit te geven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Crypto-markten vernauwen; Eigenlayer klaar om tokens uit te geven</h2><h3 id="h3-Brede20markttrend644384"><a name="Brede markttrend:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brede markttrend:</h3><p>Bitcoin (BTC), die op een gegeven moment gisteravond onder de $62.000 zakte, is weer gestegen naar boven de $64.000 in een smal oscillerende trend. Op de turbulente markt vertoont het over het algemeen een daling. Op macro-economisch niveau zijn de Amerikaanse aandelen gestegen, waarbij de aandelen van Tesla opvallend meer dan 15% zijn gestegen, wat enkele positieve signalen aan de markt toevoegt.</p>
<h3 id="h3-Markt20Hotspots180929"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><ol>
<li><p>ENA (Algorithm Stability token) steeg meer dan 20%. Dit prijsverloop kan verband houden met de aankomende ontgrendeling van tokens. Volgens de on-chain gegevens staat er volgende week een token ontgrendeling ter waarde van ongeveer $50 miljoen gepland voor ENA. De huidige rally kan worden gedreven door de ontgrendeling in afwachting van de markt.</p>
</li><li><p>Eigenlayer, het toonaangevende project in het restaken, heeft aangekondigd dat het op 10 mei een token-airdrop zal houden, met een airdrop-verhouding van 15 procent, waarvan 5 procent zal worden toegewezen aan de eerste tranche deelnemers, en de resterende 10 procent zal worden toegewezen aan de tranche van een jaar deelnemers.</p>
</li></ol>
<p>De huidige futuresprijs van Eigenlayer komt overeen met een marktkapitalisatie van $17 miljard, een waarde die veel hoger is dan die van collega-track Lido (LDO), dat een marktkapitalisatie heeft van slechts $2 miljard, hoewel de Total Locked-in Value (TVL) van Lido twee keer zo hoog is als die van Eigenlayer.</p>
<p>Bijzonder opmerkelijk is dat het aantal EIGEN-airdrops niet evenredig is met de gestorte activa, een strategie die mogelijk gunstiger is voor particuliere beleggers. De Pendle-yield-token YT op dezelfde track werd tegengehouden, waardoor Pendle kelderde. Gebruikers die hadden ingezet op Pendle ontvangen geen EIGEN-airdroptokens in de eerste ronde.</p>
<p>3.MSN, de token voor het gedecentraliseerde breedbandproject van Meson Network, werd gisteren gelanceerd op Gate.io. Twee jaar geleden had Meson Network een waarde van $250 miljoen in een financieringsronde en heeft momenteel een marktkapitalisatie van $300 miljoen. De prijs van MSN bereikte een hoogtepunt van $13 nadat het live ging, maar is sindsdien sterk gedaald naar $2.80, met een prijsprestatie die ruim onder de marktverwachtingen ligt en de voorzichtige houding van investeerders ten opzichte van het project weerspiegelt.</p>
<p>De markt verkeert momenteel in een volatiele staat, waarbij prijsschommelingen in Bitcoin en belangrijke altcoins beleggers eraan herinneren dat ze waakzaam moeten blijven op de markt. Diverse aankomende token-evenementen, zoals het ontgrendelen van ENA en de airdrop van Eigenlayer, kunnen de marktsentiment en prijsbewegingen verder beïnvloeden. Beleggers moeten de markt nauwlettend in de gaten houden en hun risico’s op passende wijze beheren, evenals aandacht besteden aan verschillende fundamentele en technische informatie om meer geïnformeerde investeringsbeslissingen te kunnen nemen.</p>
<h2 id="h2-Macro20De20prestaties20van20de20Amerikaanse20aandelenmarkt20waren20lager20dan20verwacht20terwijl20de20Aziatische20markt20maandag20goed20opende20De20wisselkoers20van20de20Japanse20yen20daalde20onder20een20kritisch20niveau824118"><a name="Macro: De prestaties van de Amerikaanse aandelenmarkt waren lager dan verwacht, terwijl de Aziatische markt maandag goed opende. De wisselkoers van de Japanse yen daalde onder een kritisch niveau." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De prestaties van de Amerikaanse aandelenmarkt waren lager dan verwacht, terwijl de Aziatische markt maandag goed opende. De wisselkoers van de Japanse yen daalde onder een kritisch niveau.</h2><p>Amerikaanse aandelen sloten maandag 29 april hoger, geleid door Tesla en Apple aandelen, omdat investeerders zich richtten op het vooruitzicht van de Federal Reserve voor rentetarieven na de beleidsvergadering van deze week.</p>
<p>Tesla-aandelen stegen met 15,3 procent, waarmee vooruitgang werd geboekt na het verkrijgen van goedkeuring van de toezichthouder om zijn Advanced Driver Assistance-programma in China te lanceren. Apple-aandelen stegen met 2,5 procent, waarbij de winsten verband hielden met hernieuwde discussies van OpenAI over het gebruik van de generatieve AI-technologie van de startup. Andere grote techbedrijven - waaronder Alphabet, Meta Platforms en Microsoft - eindigden hoger na het herstellen van vroege verliezen.</p>
<p>Wat betreft de drie belangrijkste indices steeg de Dow Jones met 0,38 procent, won de S&amp;P 0,32 procent en steeg de Nasdaq met 0,35 procent.</p>
<p>Beleggers hebben hun verwachtingen voor het tijdstip en de omvang van een renteverlaging dit jaar verlaagd vanwege onzekerheid over de vooruitzichten voor de Amerikaanse rentetarieven. Volgens de CME FedWatch-tool is de markt geprijsd op een kans van 57 procent op een renteverlaging in september.</p>
<p>Handelaren verwachten nu een renteverlaging van 35 basispunten in 2024, ruim onder de 150 basispunten die aan het begin van het jaar geprijsd waren. Deze verschuiving in verwachtingen voor Amerikaanse rentetarieven heeft de Amerikaanse staatsobligatierendementen en de dollar opgedreven, en domineert de valutamarkten. De dollar stond vrijwel ongewijzigd tegenover een mandje van valuta’s op 105,73. De index steeg meer dan 1 procent in april en meer dan 4 procent voor het jaar.</p>
<p>Deze week worden gegevens vrijgegeven, waaronder Europese inflatie en een rapport over de Amerikaanse arbeidsmarkt, terwijl de Federal Reserve gepland staat om een tweedaagse vergadering te houden op dinsdag en naar verwachting ongewijzigd zal blijven wat betreft rentetarieven.</p>
<p>Aziatische aandelen stegen lichtjes op dinsdag 30 april, terwijl beleggers in afwachting waren van een reeks economische gegevens, bedrijfswinsten en een beleidsvergadering van de Fed. De yen verzwakte lichtjes een dag nadat vermoedelijke interventies ervoor zorgden dat deze werd gered van een 34-jarige neergang.</p>
<p>De MSCI Asia-Pacific Equity Index steeg met 0,36 procent en staat op het punt om bijna 1 procent te winnen deze maand, zijn derde opeenvolgende maandelijkse winst. De Nikkei Japan heropende na de vakantie van maandag met aandelen die met 1 procent stegen.</p>
<p>Onder de topbedrijven in Azië stegen de aandelen van Samsung Electronics met 1,8 procent op dinsdag nadat het bedrijf een meer dan tien keer hogere operationele winst in het eerste kwartaal had gemeld. De vraag naar kunstmatige intelligentie van Samsung zal sterk blijven en het aanbod van sommige high-end chips beperken; chipfabrikanten kunnen profiteren van een sterke opleving op de zwaar getroffen wereldwijde markt voor geheugenchips.</p>
<p>De olieprijzen daalden lichtjes bij de opening van de handel op dinsdag, met staakt-het-vuren besprekingen tussen Israël en Hamas in Caïro, die hielpen om de marktgerelateerde zorgen over het escalerende conflict in het Midden-Oosten te kalmeren. Echter, zorgen over de vooruitzichten voor de Amerikaanse rentetarieven drukten op de markt. Amerikaanse ruwe olie daalde met 0,18 procent tot $82,48 per vat, terwijl Brent-olie met 0,1 procent daalde tot $88,31 per vat.</p>
<p>Spotgoud stond stil op $2,334.79 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Sherry S. &amp; Icing. </strong>, Onderzoeker Gate.io<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 zal worden toegestaan mits 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>