RGFnZWxpamtzIG5pZXV3cyB8IEdyYXlzY2FsZSBoZWVmdCBlZW4gJ01pbmkgQlRDJyBhYW52cmFhZyBpbmdlZGllbmQ7IEV0aGVyZXVtIERlbmN1biBVcGdyYWRlIGdlYWN0aXZlZXJkOyBCbGFzdCBFY29zeXN0ZW0gTWVtZSBDb2luIGtvbmRpZ3QgQWlyZHJvcCBhYW4=

2024-03-13, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17103022581_8.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20marktaandeel20van20GBTC20is20gedaald20tot20onder20de205020en20Grayscale20heeft20een20aanvraag20voor20een20Mini20BTC20ingediend20Ethereum20Dencunupgrade20ingeschakeld20Blast20Eco20Meme20kondigde20een20Airdrop20aan441774"><a name="Crypto Dagelijkse Samenvatting: De marktaandeel van GBTC is gedaald tot onder de 50%, en Grayscale heeft een aanvraag voor een ‘Mini BTC’ ingediend; Ethereum Dencun-upgrade ingeschakeld; Blast Eco Meme kondigde een Airdrop aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De marktaandeel van GBTC is gedaald tot onder de 50%, en Grayscale heeft een aanvraag voor een ‘Mini BTC’ ingediend; <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Dencun-upgrade ingeschakeld; Blast Eco Meme kondigde een Airdrop aan</h2><p>Volgens Dune Analytics bedroegen op 12 maart de totale activa die beheerd werden door Grayscale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het vermogen van het Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Trust (GBTC) is gedaald tot $28,5 miljard, waarvan Grayscale momenteel $56,7 miljard aan totale activa heeft, wat overeenkomt met 48,9% van de 10 Amerikaanse Bitcoin ETF’s. Sinds de lancering van negen nieuwe ETF’s in januari is het marktaandeel van Grayscale in de Bitcoin ETF-markt voor het eerst onder de 50% gezakt.</p>
<p>Grayscale heeft een aanvraag ingediend om een nieuwe ‘mini’ versie van zijn Grayscale Bitcoin Trust (GBTC) ETF te registreren met de beurscode ‘BTC.’ Op 11 maart werd een S-1 formulier ingediend bij de Securities and Exchange Commission (SEC) van de Verenigde Staten met betrekking tot ‘mini’ Bitcoin. Na goedkeuring wordt de nieuwe Grayscale ‘Bitcoin Mini Trust’ genoteerd aan de New York Stock Exchange en opereert deze onafhankelijk van Grayscale’s belangrijkste GBTC-fondsen.</p>
<p>Het document vermeldt dat het vertrouwensplan zal worden toegewezen aan bestaande GBTC-aandeelhouders, omdat GBTC ook een onbekende hoeveelheid Bitcoin zal schenken aan het nieuwe vertrouwen. Volgens Bloomberg ETF-analist James Seyfart op 12 maart heeft het nieuwe vertrouwen tot doel GBTC-beleggers belastingvrije blootstelling aan Bitcoin te bieden.</p>
<p>Op 13 maart, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De Dencun-upgrade is officieel van kracht geworden, waarbij de kern de implementatie van 9 EIP’s (Ethereum Improvement Proposals) is. Oorspronkelijk gebruikte Layer 2 voornamelijk gegevenssynchronisatie “calldata”, waarbij schrijftransacties van calldata concurrentie vereisten met alle transacties op het Ethereum-mainnet in dezelfde vergoedingsmarkt. Dit zou ertoe leiden dat de transactiekosten van Layer 2 aanzienlijk werden beïnvloed door de gas situatie op het Ethereum-mainnet, wat tijdens piekperioden gemakkelijk congestie en hoge kosten kon veroorzaken.</p>
<p>Na de implementatie van EIP-4844 zal Ethereum gegevensruimte ‘Blob’ toevoegen in het blok specifiek voor het verwerken van Layer 2-gerelateerde transacties. Layer 2 hoeft niet langer gegevens in de calldate-ruimte te schrijven. In plaats daarvan zal het Blob gebruiken om gegevenssynchronisatie-operaties uit te voeren. Layer 2-gerelateerde transacties worden behandeld als twee onafhankelijke kostmarkten met andere transacties op het mainnet, waardoor de netwerkefficiëntie aanzienlijk wordt verbeterd.</p>
<p>De Starknet Foundation heeft aangekondigd dat Starknet code-optimalisatie implementeert om kosten te verlagen. Momenteel hebben Starknet-ontwikkelaars versie 0.13.1 uitgebracht en deze maatregel wordt verwacht te worden geïmplementeerd na de upgrade naar Dencun. Aangezien bijna 90% van de Gas-kosten die Starknet betaalt voor het publiceren van transacties naar het Ethereum-mainnet worden gegenereerd door het oproepen van gegevens, wordt verwacht dat deze upgrade-optimalisatie aanzienlijke kosteneffectiviteit zal hebben.</p>
<p>Pacmoon, een lid van het Blast Eco Meme-project, heeft gepost op het X-platform en de details van PAC-luchtdrops onthuld. In de officiële verklaring wordt beweerd dat $PAC momenteel de grootste Blast-luchtdrop is, waarbij 40% van de PAC’s wordt gelucht naar drie soorten gebruikers: Blast-depositogebruikers, Vroegtijdig toegang aanbevolen gebruikers en slachtoffers van het Blast-ecosysteemrisico.</p>
<p>De airdrop aanvraag is geopend tussen 12:00 uur en 3:00 uur Eastern Time op 14 maart in de Verenigde Staten, en gebruikers hebben 14 dagen om zich aan te melden voor airdrops.</p>
<h2 id="h2-Markttrends20BTC20heeft20herhaaldelijk20nieuwe20hoogtepunten20bereikt20en20sterke20sectoren20zijn20begonnen20met20aanpassen956204"><a name="Markttrends: BTC heeft herhaaldelijk nieuwe hoogtepunten bereikt en sterke sectoren zijn begonnen met aanpassen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC heeft herhaaldelijk nieuwe hoogtepunten bereikt en sterke sectoren zijn begonnen met aanpassen.</h2><p>Er heeft een marktcorrectie plaatsgevonden, waarbij de BTC-prijs gisteravond kortstondig $68.000 bereikte en herstelde. Momenteel zijn ze boven de $72.000 gestegen. Het is vermeldenswaard dat sectoren met sterke prestaties in de vroege fase, zoals kunstmatige intelligentie (AI), Meme, enz., als eerste beginnen met aanpassen.</p>
<p>Op macro-economisch gebied steeg de Amerikaanse aandelenmarkt vandaag, maar de Consumentenprijsindex (CPI) voor februari was hoger dan verwacht, wat mogelijk enige marktvolatiliteit kan veroorzaken.</p>
<h3 id="h3-Markt20hotspots764128"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><p>Traditionele openbare blockchain munten zijn gestegen: NEAR, INJ, AVAX, TON, en andere traditionele openbare blockchain munten zijn vandaag aanzienlijk gestegen. Met name TON heeft een subsidie-incentive campagne voor makers gelanceerd en plannen aangekondigd voor een beursgang (IPO) notering. Tijdens de periode waarin de prijs steeg van $ 2,4 tot $ 4 was er bijna geen terugval, en de prestaties waren zeer sterk.</p>
<p>NFT’s op de Ethereum-keten blijven dalen: Niet-fungibele tokens (NFT’s) zoals BAYC (Bored Ape Yacht Club) op de Ethereum-keten blijven dalen, en de BAYC-vloerprijs is gedaald naar 13 ETH, een daling van 90% van de historische hoogte van 150 ETH. Voor NFT’s kan de uiteindelijke liquiditeitsvrijgave vereisen dat er tokens worden uitgegeven. Daarom zullen NFT’s zoals BAYC, die al in een vroeg stadium tokens hebben uitgegeven, het moeilijk vinden om prijsstijgingen te anticiperen.</p>
<p>Ethereum Cancun Upgrade: Rond 21:00 (Beijing tijd) vanavond zal Ethereum een Cancun-upgrade ondergaan, een belangrijke technologische update. Investeerders moeten nauwlettend de impact van kortetermijn nieuws op Layer2-tokens volgen.</p>
<p>Over het algemeen bevindt de markt zich momenteel in een fase van aanpassing, maar er zijn nog steeds enkele sectoren en projecten met sterke prestaties. Beleggers moeten waakzaam blijven, de markttrends nauwlettend volgen en hun posities aanpassen op basis van persoonlijke risicovoorkeuren en beleggingsstrategieën. Tegelijkertijd moet aandacht worden besteed aan de mogelijke impact van macro-economische gegevens en belangrijke gebeurtenissen op de markt om tijdige beslissingen te nemen.</p>
<h2 id="h2-Macro20Technologische20aandelen20stuwen20Wall20Street20hoger20De20Verenigde20Staten20kondigen20consumentenprijzen20aan20met20inflatiegegevens20hoger20dan20verwacht20Goud20maakte20de20grootste20daling20in20een20maand20mee417050"><a name="Macro: Technologische aandelen stuwen Wall Street hoger; De Verenigde Staten kondigen consumentenprijzen aan, met inflatiegegevens hoger dan verwacht; Goud maakte de grootste daling in een maand mee" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologische aandelen stuwen Wall Street hoger; De Verenigde Staten kondigen consumentenprijzen aan, met inflatiegegevens hoger dan verwacht; Goud maakte de grootste daling in een maand mee</h2><p>Op dinsdag duwden technologieaandelen Wall Street omhoog op de internationale markt, wat ook een goede basis zou moeten leggen voor de opening van de Aziatische markt op woensdag. Door de stijgende Amerikaanse obligatierendementen en de Amerikaanse inflatiegegevens die de verwachtingen overtroffen, kan de opwaartse ruimte echter beperkt zijn.</p>
<p>Overnighte gegevens tonen aan dat als gevolg van stijgende brandstof- en huisvestingskosten, consumentenprijzen in de Verenigde Staten in februari met 0,36% zijn gestegen, wat de verwachtingen overtreft, met een verwachte stijging van 0,3%. De jaarlijkse stijging van de kern-CPI vertraagde echter licht tot 3,8%; Na de publicatie van de gegevens steeg het rendement op Amerikaanse staatsobligaties. Bij het sluiten van de New York-sessie steeg het rendement op tweejarige staatsobligaties met 6,5 basispunten tot 4,599%, en het rendement op tienjarige staatsobligaties steeg met 5,1 basispunten tot 4,155%. De ochtendhandel in Tokio bleef stabiel.</p>
<p>De tweede opeenvolgende maand van sterker-dan-verwachte inflatie maakt de mogelijkheid van de Federal Reserve om de rente te verlagen voor juni teniet. Het maakt de mogelijkheid van opeenvolgende renteverlagingen daarna steeds kleiner. Ondertussen zorgden benzine- en huizenprijzen voor een stijging van de consumentenprijsindex met 3,2% in februari, een stijging van 3,1% vergeleken met vorig jaar. De vertraging in de basis kerninflatie (exclusief aardgas- en voedselprijzen) was lager dan verwacht door economen en behaalde groei op basis van drie en zes maanden.</p>
<p>De Standard &amp; Poor’s 500 Index (.SPX) steeg met 1,1%, waarmee een nieuw recordhoogtepunt werd bereikt. De aandelenprijs van databasegigant Oracle Inc. (ORCL.N) steeg met 12% nadat de winst van het bedrijf de verwachtingen overtrof en meldde dat het op het punt stond een partnerschap aan te kondigen met marktdarling NVIDIA (NVDA.O).</p>
<p>De MSCI, de meest gebruikte Azië-Pacific aandelenindex buiten Japan (.MIAPJ0000PUS), steeg met 0,2% en bereikte het hoogste niveau sinds begin augustus. De Hang Seng Index (HSI) steeg met 0,4% naar een hoogtepunt van drieënhalve maand. De Tokyo Nikkei Index (.N225) bleef stabiel, met de focus van Japan op de loononderhandelingen van deze week, waarbij verwacht wordt dat negatieve rentetarieven begin volgende week worden afgeschaft. De vakbondsbesprekingen kunnen loonsverhogingen bevorderen.</p>
<p>Wat betreft goudprijzen daalden de goudprijzen dinsdag met 1,1%, de meest ernstige daling op één dag sinds 13 februari, toen gegevens aantoonden dat de consumentenprijzen in januari ook meer dan verwacht stegen.</p>
<p>Ruwe olie-futures schommelen al enkele weken binnen een bereik, waarbij Brent-ruwe olie uiteindelijk met 0,5% stijgt naar $82,36 per vat.</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 herposten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>