RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBlbiBFVEggYmxpanZlbiBkYWxlbjsgRGVuY3VuIFVwZ3JhZGUga2FuIEV0aGVyZXVtIG9wbmlldXcgZG9lbiBvcGJsYXplbjsgU29waG9uIGhhYWxkZSAkNjAgbWlsam9lbiBvcCB2aWEgJ05vZGUgU2FsZXMn

2024-05-09, 03:56

<p><img src="https://gimg2.gateimg.com/image/article/17152269481_5.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Dencunupgrade20kan20opnieuw20leiden20tot20Ethereuminflatie20Sophon20haalde206020miljoen20op20via20nodeverkopen20Lyra20Finance20lanceert20nieuwe20token20LDXluchtafzet594223"><a name="Crypto Dagelijkse Samenvatting: De Dencun-upgrade kan opnieuw leiden tot Ethereum-inflatie; Sophon haalde $60 miljoen op via ‘node-verkopen’; Lyra Finance lanceert nieuwe token LDX-luchtafzet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Dencun-upgrade kan opnieuw leiden tot Ethereum-inflatie; Sophon haalde $60 miljoen op via ‘node-verkopen’; Lyra Finance lanceert nieuwe token LDX-luchtafzet</h2><p>Een rapport van data bedrijf CryptoQuant suggereert dat de upgrade naar Dencun kan leiden tot nog een inflatie in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, omdat de transactiekosten van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> zijn gedaald en de verbranding tot een van de laagste niveaus is gedaald sinds de fusie. Deze verminderde verbranding heeft geleid tot een ongekende groei in het aanbod van Ethereum, wat voor het eerst is sinds de fusie van het Ethereum-netwerk.</p>
<p>Analisten wijzen erop dat vóór de upgrade van Dencun, hogere activiteitsniveaus op het Ethereum-netwerk leidden tot hogere transactiekosten, wat resulteerde in een lagere Ethereum-voorraad. Met de implementatie van de Dencun-upgrade is de relatie tussen verbrandingskosten en netwerkactiviteiten echter losgekoppeld.</p>
<p>Over het algemeen is de conclusie uit het rapport dat Ethereum ‘waarschijnlijk geen deflatie meer zal ervaren’ omdat op het huidige niveau van online activiteit de inflatie van Ethereum kan doorgaan en de waardedaling van ETH onvermijdelijk is. Dit betekent dat ETH mogelijk niet langer de kenmerken van een ‘supersonische valuta’ bezit, of dat het herstellen van deze functie een hoger niveau van online activiteit kan vereisen.</p>
<p>Volgens het block rapport heeft zkSync’s “hyperchain” Sophon met succes ongeveer $60 miljoen opgehaald via node-verkopen.</p>
<p>“Hyperchain” Sophon, is een Layer 2-netwerk gebouwd op het modulaire open-source framework ZK Stack van Matter Labs. Sales boden koopmogelijkheden voor 200.000 nodes en hebben een gelaagd prijsmodel aangenomen; Op woensdag verklaarde het bedrijf dat investeerders 121.000 nodes hebben gekocht, waardoor Sophon ongeveer $60 miljoen aan wETH heeft verdiend.</p>
<p>Sebastien, medeoprichter van Sophon en voormalig DeFi-manager bij zkSync, verklaarde dat Sophon 20800 wETHs heeft opgehaald. Sebstien verklaarde dat de verkoop van nodes gemeenschappen in staat stelt om projecttokens tegen gereduceerde prijzen in de vroege stadia te verwerven en token-airdrops te ontvangen.</p>
<p>Sophon is van plan om zijn netwerk in de komende maanden te lanceren. Rond die tijd wordt ook gezegd dat er een gecentraliseerde sorteermachine zal zijn waar node-houders hun licenties aan Sophon kunnen delegeren en hun aandeel in netwerkvergoedingen kunnen ontvangen. Het project stelt: “Deze houders zullen ook in staat zijn om deel te nemen aan de activiteiten van Sophon, zoals het draaien van lichte nodes via indexketens of het gebruik van door Sophon geselecteerde gegevensbeschikbaarheidslagen.”</p>
<p>Sophon heeft bepaald dat 20% van de totale voorraad aan tokens (SOPH) zal worden gedistribueerd naar houders van node-licenties binnen de eerste 36 maanden nadat het mainnet van Sophon is gelanceerd.</p>
<p>Het DeFi-instrument Lyra Finance heeft een token-transformatieplan aangekondigd, waarbij de LDX-token wordt gelanceerd als de inheemse valuta van het Lyra-derivatennetwerk, met plannen om deze in het derde kwartaal van dit jaar te lanceren. De bestaande Lyra-tokens worden gemigreerd naar de nieuwe tokens. En ze zijn van plan om LDX-airdrops uit te voeren om handelaren en winstboeren te belonen, hen aan te moedigen om de liquiditeit en adoptiegraad van Lyra-producten te vergroten. De airdrop zal een integraal systeem aannemen, waarbij LDX proportioneel wordt toegewezen elke vier weken.</p>
<p>Lyra heeft ook een product gelanceerd dat winstgevende derivaten tokeniseert, waarbij in eerste instantie de nadruk ligt op basis handel, en later een strategie voor gedekte callopties voor liquiditeits-herplaatsingstokens op EigenLayer wordt gelanceerd. Dit stelt gebruikers in staat om LRT’s die zijn uitgegeven door protocollen zoals EtherFi (eETH) en Swell (rswETH) te storten om winst te maken. Dit protocol zal beleidsregels op LRT tokeniseren en ze verpakken in de vorm van ERC-20 tokens.</p>
<p>Lyra Finance werd oorspronkelijk geïntroduceerd als een on-chain optiehandelsprotocol, met behulp van market maker vaults en een specifieke activapool gefinancierd door liquiditeitsverschaffers die stablecoins inruilen voor een deel van de handelskosten.</p>
<h2 id="h2-Markttrends20BTC20blijft20dalen20IO20staat20op20het20punt20om20token20airdrops20te20doen180370"><a name="Markttrends: BTC blijft dalen, IO staat op het punt om token airdrops te doen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC blijft dalen, IO staat op het punt om token airdrops te doen</h2><p>In de afgelopen 24 uur is de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) heeft aanzienlijke schommelingen meegemaakt, is op een gegeven moment onder de $61.000 gezakt en is nu lichtjes hersteld tot ongeveer $61.500. Ethereum (ETH) is ook onder de $3.000 gezakt, en de gehele Altcoin-markt heeft ook een klap gekregen. Bovendien heeft de markt een voortdurende uitstroom van spot-ETF’s waargenomen, wat wijst op de voorzichtige houding van investeerders. Op het gebied van macro-economie is de prestatie van Amerikaanse aandelen volatiel geweest, en de markt wacht op de Consumentenprijsindex (CPI) gegevens van volgende week als een belangrijke indicator om toekomstige economische en beleidsrichtingen te beoordelen.</p>
<h3 id="h3-Markt20Hotspots372343"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Oracle Protocol: Teller (TRB) maakte een driedubbele prijsstijging mee binnen een paar dagen en ondervond toen een daling. Deze prijsvolatiliteit toont meestal het gedrag van sterke valuta in volatiele markten, waar ze snel stijgen en dan met dezelfde intensiteit dalen. Bovendien heeft de fluctuatie van TRB ook geleid tot de stijging van andere oracle protocol tokens zoals UMA en API3. API3 heeft onlangs een partnerschap aangekondigd met Xlayer’s Layer2, wat mogelijk een factor is die de prijsstijging stimuleert.</p>
<p>De ontwikkeling van het DePIN-concept: Io.net, het vlaggenschipproject van het DePin-concept, heeft de lancering van IO-tokens aangekondigd, met een toekomstige prijs van $3,66 op DEX, wat overeenkomt met een marktwaarde van bijna $2 miljard. Er wordt verwacht dat IO-tokens medio mei worden airdropped, wat mogelijk marktinteresse in IO stimuleert. Ondanks de langdurige hype rond DePIN-gerelateerde concepten, zijn de concepttokens op dit gebied nog niet collectief geëxplodeerd. Andere tokens op dezelfde koers, zoals RNDR en AKT, hebben respectievelijk marktwaarden van $5 miljard en $1 miljard, wat de diepgaande potentie van dit gebied aantoont.</p>
<p>De belangrijkste markttrend in deze ronde draait nog steeds om AI en Meme tokens. Met de aankomende release van belangrijke CPI-gegevens volgende week kan de markt te maken krijgen met grotere volatiliteit. Investeerders moeten waakzaam blijven en aandacht besteden aan de ontwikkeling van macro-economische indicatoren en gerelateerde crypto-projecten om hun strategieën tijdig aan te passen in reactie op mogelijke marktveranderingen.</p>
<h2 id="h2-Macro20De20Amerikaanse20markt20is20fluctuerend20de20Aziatische20markt20is20stabiel20en20goud20en20olieprijzen20stijgen723401"><a name="Macro: De Amerikaanse markt is fluctuerend, de Aziatische markt is stabiel en goud- en olieprijzen stijgen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Amerikaanse markt is fluctuerend, de Aziatische markt is stabiel en goud- en olieprijzen stijgen.</h2><p>Op donderdag sloot de Dow Jones Industrial Average hoger op woensdag, toen investeerders bleven wedden op de ondersteuning van het Amerikaanse monetair beleid. De index steeg voor de zesde opeenvolgende handelsdag en sloot voor het eerst in vijf weken boven de 39000 punten. Vanwege de stagnatie van de momentum op de dag van de veiling van 10-jarige schatkistobligaties en de stijging van de opbrengst van Amerikaanse schatkistobligaties, koelden andere benchmark indexen op Wall Street iets af. De S&amp;P 500-index sloot vlak na vier opeenvolgende handelsdagen te zijn gestegen, terwijl de Nasdaq Composite-index voor de tweede opeenvolgende handelsdag daalde.</p>
<p>Wat betreft de stijging en daling van de drie belangrijkste indexen, bleef de S&amp;P 500 index onveranderd, daalde de Nasdaq met 0,18% en steeg de Dow Jones index met 0,44%.</p>
<p>De Federal Reserve-beleidsmakers die woensdag spraken, zijn in overeenstemming met recente informatie, inclusief tijdens de Federal Reserve-beleidsvergadering van vorige week. Susan Collins, vertegenwoordiger van Boston, zei dat het huidige monetair beleid de economie zal vertragen, wat volgens haar noodzakelijk is voor het doel van de Federal Reserve om de inflatie terug te brengen naar 2%.</p>
<p>Volgens de Fedwatch-tool van CMEGroup voorspellen handelaren een kans van 67% dat de Federal Reserve de rente in september met minstens 25 basispunten verlaagt, tegenover 54% een week geleden.</p>
<p>Het beleid en de marktprestaties in Azië en Europa zijn behoorlijk verschillend. Op donderdag 9 mei stabiliseren de Aziatische aandelenmarkten zich momenteel en wachten investeerders op de handelsgegevens van China om de gezondheid van de Chinese economie te meten; Japan heeft mogelijk valutainterventie aangegeven, waarbij de yen stabiliseert na drie opeenvolgende dagen van daling.</p>
<p>Na de overnachtingstarievenverlaging door de Zweedse centrale bank, zal ook de Bank of England (BoE) beslissen over haar rentebeleid en overwegen hoe lang het zal duren om de rentetarieven te verlagen van het huidige 16-jarige hoogtepunt. Iedereen maakt zich zorgen over de mogelijkheid van een renteverlaging in juni, wat ook de verschillen tussen Europa en de Federal Reserve benadrukt.</p>
<p>Ondertussen is de arbeidsmarkt in het VK een aandachtspunt geworden. Uit de laatste officiële gegevens blijkt dat in de drie maanden tot en met februari het jaarlijkse loongroeipercentage ongeveer 6% bedroeg, terwijl de werkloosheid steeg naar 4,2%, wat een zes maanden hoogtepunt bereikte. De taak van tewerkstelling is complexer geworden.</p>
<p>REC verklaarde dat steeds meer mensen toetreden tot de arbeidsmarkt en dat kandidaten in het afgelopen jaar met de snelste snelheid groeien, mede als gevolg van een toename van ontslagen en een algemene toename van werkzoekenden. De toename van het arbeidsaanbod wordt door de regering verwelkomd, aangezien de regering en de centrale bank zich zorgen maken over de inflatie en de fiscale impact als gevolg van de voortdurende daling van de arbeidsparticipatie in de afgelopen twee jaar.</p>
<p>Op de Aziatische markt steeg de MSCI Asia Pacific Stock Index met 0,1%, nadat voorzitter van de Federal Reserve Jerome Powell later dit jaar zijn ‘ruime beleidskoers’ herhaalde, niet ver van het vorige hoogtepunt van 15 maanden. De Nikkei-index in Japan steeg met 0,3%.</p>
<p>Vanwege een herstel van 2% in technologische aandelen en de opleving van Chinese vastgoedontwikkelaars, stegen Chinese blue chip aandelen met 0,6%, terwijl de Hong Kong Hang Seng Index aandelenmarkt met 0,7% steeg. De CSI vastgoedindex steeg met 0,9%, na het dalen van de vorige dag.</p>
<p>Beleggers zullen aandacht besteden aan de Amerikaanse consumenteninflatiegegevens van april die volgende woensdag worden vrijgegeven om een beter inzicht te krijgen in de beleidsrichting van de Federal Reserve; De gegevens zijn onverwachts gestegen gedurende drie opeenvolgende rondes.</p>
<p>Wat betreft grondstoffen wijst de daling van de Amerikaanse voorraden ruwe olie op een aanscherping van het aanbod en de groeiende hoop dat de Federal Reserve de rente zal verlagen vóór het einde van het jaar heeft geleid tot een lichte stijging van de olieprijzen op donderdag, na een tweemaandelijkse laagste punt op de vorige handelsdag. Brent ruwe olie futures stegen met 0,2% naar $83,76 per vat, terwijl de Amerikaanse ruwe olie futures met 0,3% stegen naar $79,24 per vat.</p>
<p>De goudprijs steeg met 0,1% naar $2.311,23 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 beleggingsaanbeveling.<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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>