RGFnZWxpamtzIG5pZXV3cyB8IEV0aGVyZXVtIERlbmNodW4gTWFpbm5ldC11cGdyYWRlIGFhbmdla29uZGlnZDsgRGUgZGllZnN0YWwgdmFuIGRlIHByb2plY3Rwb3J0ZW1vbm5lZSB6b3JnZGUgdm9vciBlZW4gZGFsaW5nIHZhbiA5OSUgaW4gU0VSU0gu

2024-02-28, 06:24

<p><img src="https://gimg2.gateimg.com/image/article/17091013171_19.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Ethereum20Denchun20Mainnet20Upgrade20Aankondiging20Uitgebracht20Serenity20Shield20project20portemonnee20gestolen20tokenprijs20daalt20met2099824816"><a name="Crypto Dagelijkse Samenvatting: Ethereum Denchun Mainnet Upgrade Aankondiging Uitgebracht; Serenity Shield project portemonnee gestolen, tokenprijs daalt met 99%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Denchun Mainnet Upgrade Aankondiging Uitgebracht; Serenity Shield project portemonnee gestolen, tokenprijs daalt met 99%</h2><p>Met betrekking tot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF-handelsactiviteiten, op 27 februari, GBTC-uitstroom ongeveer $125 miljoen, waardoor de bezittingen van 2200 BTCs gisteren werden verminderd. Inflow van ARK 21Shares <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (ARKB) van $5,4 miljoen gisteren, en WisdomTree Bitcoin spot ETF (BTCW) netto-inflow van $3,6 miljoen. Inflow van Fidelity Bitcoin spot ETF (FBTC) van $126 miljoen gisteren.</p>
<p>De totale handelsvolume van 9 Bitcoin spot ETF’s overschreed gisteren opnieuw $2 miljard (27 februari). Daarvan doorbrak BlackRock Bitcoin Spot ETF (IBIT) zijn historische hoogtepunt met een handelsvolume van $1,3 miljard, dat het handelsvolume van de meeste grote Amerikaanse aandelen overtrof.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Foundation heeft een upgrade-aankondiging uitgebracht voor het Denchun mainnet. Denchun wordt naar verwachting geactiveerd op het Ethereum mainnet om 13:55 UTC Beijing-tijd op 13 maart 2024. De blokhoogte is 269.568 en node-operators en stakers moeten hun software upgraden naar de versie vermeld in de aankondiging.</p>
<p>Deze upgrade is een andere upgrade na de Shapella-upgrade van vorig jaar, die meerdere wijzigingen omvat, met name de introductie van tijdelijke gegevensblobs via EIP-4844 (ook bekend als protodanksharding), die zullen helpen om de kosten van L2-handel te verlagen.</p>
<p>Serenity Shield, een project dat beweert een ‘crypto-erfenis’ oplossing te zijn, is aanglen en de onderliggende token is bijna 99% gedaald. Volgens de aankondiging van het projectteam op het X-platform werd eerder een Metamask-portemonnee die liquiditeit voor SERSH-tokens vasthoudt gehackt, waardoor bijna 7 miljoen SERSH-tokens naar een onbekende derde partij-portemonnee werden overgeboekt. Dit evenement resulteerde in een aanzienlijke daling van de tokenprijzen.</p>
<p>Als preventieve maatregel is de officiële reactie om alle transacties, stortingen en opnames van de centrale exchange op te schorten om verdere problemen te voorkomen. Ondertussen is besloten om een nieuw token smart contract te gebruiken om SERSH tokens opnieuw te lanceren, met als doel het minimaliseren van het risico op beveiligingsincidenten. Tijdens de periode van token heruitgifte, alle liquiditeit opnieuw inzetten naar het nieuwe contract en eventueel verwijderde liquiditeit als gevolg van Metamask compromis vervangen.</p>
<p>De SERSH-token werd ongeveer twee maanden geleden gelanceerd en de kwetsbaarheid deed zich voor op de ochtend van 27 februari om 9:11. 9,116,9 miljoen SERSH (geprijsd op $0,82) werd overgeboekt van een MetaMask-portemonnee van het project naar een niet-geïdentificeerde portemonnee van een derde partij. Daarna vertoonde de prijs van SERSH ongeveer 5 uur lang een neerwaartse trend en daalde vervolgens plotseling met 98% van $0,565 naar $0,009 binnen 5 minuten. Momenteel keert de prijs terug naar normaal.</p>
<h2 id="h2-Macro20De20waarschijnlijkheid20dat20de20rente20onveranderd20blijft20is20bijna2010020De20Amerikaanse20inflatietest20komt20binnenkort20en20Aziatische20aandelenmarkten20zijn20traag20Kleine20schommelingen20in20goud20en20ruwe20olieprijzen300833"><a name="Macro: De waarschijnlijkheid dat de rente onveranderd blijft, is bijna 100%; De Amerikaanse inflatietest komt binnenkort en Aziatische aandelenmarkten zijn traag; Kleine schommelingen in goud- en ruwe olieprijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De waarschijnlijkheid dat de rente onveranderd blijft, is bijna 100%; De Amerikaanse inflatietest komt binnenkort en Aziatische aandelenmarkten zijn traag; Kleine schommelingen in goud- en ruwe olieprijzen</h2><p>Volgens de CME ‘Federal Reserve Watch’ tool is de waarschijnlijkheid dat de Federal Reserve de rentetarieven in maart handhaaft in het bereik van 5,25% - 5,50% 99%, en de kans op een renteverlaging van 25 basispunten is 1%. De waarschijnlijkheid om de rentetarieven ongewijzigd te handhaven tegen mei is 79,7%, de kans op een cumulatieve renteverlaging van 25 basispunten is 20,1%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten is 0,2%.</p>
<p>De gegevens van dinsdag toonden aan dat duurzame goederenbestellingen in de Verenigde Staten in januari de grootste daling in bijna vier jaar hebben meegemaakt. Ook daalde de index van het consumentenvertrouwen in de VS in februari. Investeerders richten zich op de voorkeursinflatie-indicator van de Federal Reserve, de Index van de Persoonlijke Consumptie-uitgavenprijs (PCE) van januari, die op donderdag is aangekondigd. Uit een Reuters-enquête blijkt dat de maandelijkse tarief van de index van de persoonlijke consumptie-uitgavenprijs naar verwachting in januari met 0,3% zal stijgen, iets hoger dan de 0,2% in december.</p>
<p>Volgens Reuters kan de inflatiedata van de VS deze week van invloed zijn op het tijdstip van de versoepelingscyclus van de Federal Reserve. Voor de publicatie van specifieke gegevens presteerden Aziatische aandelenmarkten voorzichtig op woensdag, waarbij de Asia Pacific Index van Morgan Stanley Capital International (MSCI), de meest gebruikte aandelengraadmeter buiten Japan (MIAPJ0000PUS), met 0,11% daalde tot 527,14 punten, maar rond een bijna zeven maanden hoogtepunt van 531,56 punten schommelde. De Chinese aandelenmarkt zag gemengde winsten en verliezen in de vroege handelssessie, waarbij de Hang Seng Index van Hong Kong met 0,31% daalde en Chinese blue chip-aandelen zoals de CSI 300 Index met 0,46% stegen.</p>
<p>De Nieuw-Zeelandse dollar daalde scherp nadat de Bank of New Zealand haar havikachtige standpunt over de rentetarieven had verzacht. De Bank of New Zealand stabiliseerde haar kasrente op 5,5% op woensdag en bevestigde dat eerdere renteverhogingen zouden helpen om de prijzen te beteugelen, maar voegde eraan toe dat het risico op verdere renteverhogingen is verminderd. De Nieuw-Zeelandse dollar sloot op $0,61235, een daling van 0,75% op dezelfde dag.</p>
<p>De Japanse yen blijft op een psychologisch kritieke prijs van 150 yen per Amerikaanse dollar, met het laatste rapport van 150,43 yen per Amerikaanse dollar. De Nikkei Index (.N225) daalde dezelfde dag met 0,2% en bereikte deze week een historisch hoogtepunt.</p>
<p>De goudprijzen stegen lichtjes op woensdag omdat de Amerikaanse schatkistrendementen daalden en beleggers zich richtten op belangrijke Amerikaanse inflatiedata deze week en toespraken van verschillende functionarissen van de Federal Reserve op zoek naar nieuwe aanwijzingen over rentetarieven. Spot goud steeg met 0,1% naar $2.031,99 per ounce. Amerikaanse futures daalden met 0,2% naar $2.041,00 per ounce. Het rendement op 10-jarige Amerikaanse staatsobligaties is gedaald van 4,3150% naar 4,2934%, waardoor niet-rendementsgoud aantrekkelijker is.</p>
<p>Wat ruwe olie betreft, daalde Amerikaanse ruwe olie met 0,41% naar $78,55 per vat; Brent ruwe olie werd gemeld op $83,31 per vat, een daling van 0,41% op de dag.</p>
<p>Het vooruitzicht van een vertraagde cyclus van renteverlagingen in de VS heeft de markt voorzichtig gemaakt, waardoor de impuls veroorzaakt door OPEC en verlengde productieverlagingen teniet wordt gedaan.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</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 zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>