RGFnZWxpamtzIG5pZXV3cyB8IExpZG8ncyBhYW5kZWVsIGluIGRlIFN0YWtlZCBFVEgtbWFya3QgZGFhbHQgb25kZXIgZGUgMzAlLCBGYW50b20gbGFuY2VlcmRlIGRlIGRvb3IgZGUgQW1lcmlrYWFuc2UgZG9sbGFyIGdlc3RldW5kZSBzdGFibGVjb2luIFVTREMuZSwgUmlwcGxlIHBsYW5uZW4gb20gc3RhYmxlY29pbnMgdWl0IHRlIGd

2024-04-05, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17122891321_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Satoshi20Nakamoto20kan20zijn2049e20verjaardag20omarmen20het20marktaandeel20van20gestaked20Ethereum20van20Lido20is20onder20de203020gedaald20Fantom20heeft20vandaag20de20lancering20aangekondigd20van20de20door20de20Amerikaanse20dollar20gedekte20stablecoin20USDCe20en20Ripple20is20van20plan20stablecoins20uit20te20geven20die20gekoppeld20zijn20aan20de20Amerikaanse20dollar173031"><a name="Crypto Dagelijkse Samenvatting: Satoshi Nakamoto kan zijn 49e verjaardag omarmen, het marktaandeel van gestaked Ethereum van Lido is onder de 30% gedaald, Fantom heeft vandaag de lancering aangekondigd van de door de Amerikaanse dollar gedekte stablecoin USDC.e, en Ripple is van plan stablecoins uit te geven die gekoppeld zijn aan de Amerikaanse dollar." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Satoshi Nakamoto kan zijn 49e verjaardag omarmen, het marktaandeel van gestaked <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> van Lido is onder de 30% gedaald, <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> heeft vandaag de lancering aangekondigd van de door de Amerikaanse dollar gedekte stablecoin USDC.e, en Ripple is van plan stablecoins uit te geven die gekoppeld zijn aan de Amerikaanse dollar.</h2><p>Volgens de verjaardag die Satoshi Nakamoto invulde bij het registreren van een account op p2pfoundation, was het 5 april 1975. Vandaag, 5 april 2024, is zijn 49e verjaardag.</p>
<p>Volgens DeFiLlama-gegevens heeft de Ethena TVL de grens van $2 miljard overschreden en staat momenteel op $2,005 miljard, wat een nieuwe hoogtepunt is met een groeipercentage van 43,33% in 7 dagen.</p>
<p><a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> heeft aangekondigd dat zijn officieel erkende stablecoin USDC.e vandaag zal worden gelanceerd, ondersteund door Circle en Wormhole. De USDC.e op Wormhole is overbrugd van de inheemse USDC en bevindt zich in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het slimme contract van Gate.io. Het is mogelijk om in de toekomst te upgraden naar de inheemse USDC. Het zal de officiële en erkende stablecoin worden voor het Fantom-ecosysteem (en alle toekomstige netwerkupgrades).</p>
<p>SingularityNET verklaarde op het X-platform dat de voorgestelde stemming over de fusie van SingularityNET, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, en Ocean Protocol-tokens is nu open voor AGIX-tokenhouders op <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> en Ethereum. De deadline is 20:00 op 16 april (UTC+8).</p>
<p>Dune-gegevens tonen aan dat het totale bedrag van ETH dat is gestaked op de Ethereum beacon chain 32.073.148 bedraagt, wat overeenkomt met 26,76% van het totale aanbod van ETH. Daarvan is het aandeel van het liquiditeitsstakingprotocol Lido gedaald tot onder de 30%, en bedraagt nu 29,7%.</p>
<p>Volgens CoinDesk zal Ripple stablecoins uitgeven die gedekt worden door de Amerikaanse dollar, waardoor er meer praktisch nut en liquiditeit ontstaat. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Grootboek.</p>
<h2 id="h2-Markttrends20BTC20stijgt20lichtjes20met20een20grote20populariteit20van20nieuwe20munten861900"><a name="Markttrends: BTC stijgt lichtjes, met een grote populariteit van nieuwe munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC stijgt lichtjes, met een grote populariteit van nieuwe munten</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) steeg gisteren van ongeveer $65.000 naar $69.000, wat de marktwaarde verhoogde en een collectieve stijging in de Altcoin-sector veroorzaakte. Volgens gegevens uit de optiemarkt, hoewel de markt deze week een maximale correctie van bijna 10% heeft doorgemaakt, worden de verwachtingen van marktvolatiliteit nog steeds snel verminderd. Met de eerste week van levering na de kwartaal grote levering vandaag, is BTC Dvol gedaald tot onder de 70%, en de IV neerwaartse druk die vorige maand werd genoemd, blijft vrijkomen. Onlangs was de prestatie van de bulkhandelsmarkt zwak, en investeerders kiezen voornamelijk voor het kopen van gehalveerde call-opties als hun beleggingsstrategie.</p>
<h3 id="h3-Markt20Hotspots456513"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Hong Kong concept sector: De Hong Kong <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Carnival 2024 zal plaatsvinden van 6 tot 9 april op de 3FG van het Hong Kong Convention and Exhibition Center. Enkele projecten uit de Hong Kong concept sector, zoals Alchemy Pay (ACH), Conflux (CFX), Nervos Network (CKB), <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">De Sandbox</a> (SAND) en <a href="/price/mask-network-mask" target="_blank" class="blog_inner_link">MASK Network</a> (MASK) hebben onlangs aanzienlijke winsten geboekt.</p>
<p>MEME sector: Meme coins zijn de laatste tijd de meest populaire sector, vooral <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> in maart en Base Chain in april. Meme munten zijn een hete bron geworden voor deze publieke keten ecoen om uit te breiden. In de nabije toekomst kan Elon Musk’s enkele GROK de MEME-rage blijven leiden.</p>
<p>ENA: Ethena (ENA) heeft onlangs marktpopulariteit gewonnen vanwege zijn sterke stablecoin-inkomsten. Momenteel heeft het TVL de $2 miljard overschreden, met een groeisnelheid van 43,33% in 7 dagen, waardoor het een van de meest populaire projecten is samen met PENDLE in dezelfde race. Ethena heeft een nieuw type crypto-native obligatie gecreëerd door rendementen van gestaked Ethereum te combineren met fondsen en basis van de eeuwige en futuresmarkten. Bovendien kunnen gebruikers USDe kopen of verkopen via externe AMM-pools met stablecoin-onderpand (zoals USDT of USDC), een synthetische Amerikaanse dollar onder het Ethena-protocol. Gebruikers kunnen ook USDe staken en destaken om een overeenkomstig aandeel in de winst te verkrijgen.</p>
<p>W: Wormhole (W): Wormhole werd aanvankelijk geïncubeerd en ondersteund door Jump Crypto, met als doel ontwikkelaars in staat te stellen native cross-chain applicaties te bouwen die meerdere ketens omvatten. Het is nu geëvolueerd van een bidirectionele cross-chain bridge gericht op Ethereum en <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> naar een universeel berichtenprotocol dat meerdere ketens ondersteunt, en is daarmee een toonaangevend project geworden in de cross-chain sector. Onlangs, na de lancering van de token W, is deze gestegen naar $1,79, met een huidige 24-uurs daling van 17,66%.</p>
<p>Over het algemeen zijn de recente markthotspots geconcentreerd geweest op nieuw gelanceerde tokens en de MEME-sector met snelle rendementen. Dit biedt een saaie achtergrond van de huidige hoge volatiliteit van Bitcoin, en de marktspeculatieconsensus heeft nog geen zeer eenduidige consensus gevormd. Het rotatieritme van populaire sectoren en tokens is snel.</p>
<h2 id="h2-Macro20Fedfunctionarissen20gaven20aan20dat20er20geen20haast20is20om20de20rentetarieven20in20de20nabije20toekomst20te20verlagen20en20de20drie20belangrijkste20Amerikaanse20aandelenindexen20sloten20lager136489"><a name="Macro: Fed-functionarissen gaven aan dat er geen haast is om de rentetarieven in de nabije toekomst te verlagen, en de drie belangrijkste Amerikaanse aandelenindexen sloten lager." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fed-functionarissen gaven aan dat er geen haast is om de rentetarieven in de nabije toekomst te verlagen, en de drie belangrijkste Amerikaanse aandelenindexen sloten lager.</h2><p>Op donderdag hebben verschillende functionarissen van de Federal Reserve verklaard dat de inflatie hoog blijft, dat er geen haast is om de rente te verlagen en dat de veerkracht van de arbeidsmarkt wordt erkend.</p>
<p>De intensieve toespraken van functionarissen van de Federal Reserve volgden op de toespraak van de voorzitter van de Federal Reserve, Powell, van gisteren. Powell benadrukte woensdag dat de Federal Reserve tijd heeft om de aankomende gegevens te ueren voordat zij de rentetarieven verlagen, wat aangeeft dat beleidsmakers bereid zijn te wachten op meer duidelijke tekenen van inflatiedaling voordat zij actie ondernemen.</p>
<p>Voorzitter Cashkali van de Minneapolis Federal Reserve heeft onverwacht verklaard dat de inflatie dit jaar is gestegen en dat er mogelijk geen renteverlaging komt, wat de markt schokte. Overeenkomstig de prestaties van de Amerikaanse aandelenmarkt opende de S&amp;P 500-index hoog op de dag. Het bleef nauwkeurig schommelen boven de 5.240 punten voordat Kashkari begon te spreken, en bereikte een maximum van 5.256,59 punten. Na de havikachtige toespraak van Kashkari nam de Amerikaanse aandelenmarkt een sterke wending en daalde binnen 20 minuten tot een dagelijks laagtepunt van ongeveer 5.146,06 punten voordat deze sloot.</p>
<p>Maar er zijn ook voorzitters van de Chicago Fed die meer duifachtig zijn omdat ze zich zorgen maken over mogelijke problemen op de arbeidsmarkt.</p>
<p>Echter, uiteindelijk leden alle 11 sectoren van de S&amp;P 500 index een volledige ineenstorting op de vooravond van de publicatie van de non-farm payroll, waarbij AMD meer dan 8,2% daalde en AMD ongeveer 5,7% daalde, wat leidde tot de daling van de technologiesector.</p>
<p>In tegenstelling tot de zwakke trend van de Amerikaanse aandelenmarkt, neemt de omvang van de geldmarktfondsen voortdurend toe.</p>
<p>Vanwege de laatste verklaring van de Federal Reserve waarin wordt aangegeven dat functionarissen niet overhaast zijn om een renteverlaging door te voeren, verwachten beleggers over het algemeen dat de korte-termijn rentetarieven hoog zullen blijven, waardoor de omvang van de activa van Amerikaanse geldmarktfondsen historische hoogtepunten bereikt. Volgens de laatste gegevens die zijn vrijgegeven door de Investment Company Association, trokken Amerikaanse geldmarktfondsen in de week die eindigde op 3 april ongeveer $70,5 miljard aan instroom aan, de grootste wekelijkse toename in bijna drie maanden. Tegelijkertijd is de totale omvang van de fondsactiva gestegen van $6,04 biljoen in de voorgaande week tot $6,11 biljoen. Sinds de Federal Reserve in 2022 zijn meest agressieve verkrappende beleid lanceerde, hebben particuliere beleggers ervoor gekozen om hun geld in geldmarktfondsen te investeren.</p>
<p>Bovendien zal de Verenigde Staten vanavond haar gegevens over de werkloosheidscijfers van maart vrijgeven. Sterke Amerikaanse economische gegevens hebben de waarschijnlijkheid van een renteverlaging door de Federal Reserve in mei aanzienlijk verminderd. De waarschijnlijkheid van een renteverlaging in mei is gedaald van 90% vorige maand tot de huidige 50%, wat wijst op een verandering in de marktverwachtingen voor het toekomstige monetaire beleid van de Fed.</p>
<p>Over het algemeen heeft de cryptomarkt onlangs een hoge en sterke trend laten zien. Er zijn echter nog steeds enkele onzekerheden in de toekomstige trends van de cryptomarkt als gevolg van de afname van de marktvolatiliteit en veranderingen in verwachte renteverlagingen. Investeerders moeten niet alleen aandacht besteden aan de contanten. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> van spot ETF’s, maar ook hun aandacht richten op de beleidswijziging van de Federal Reserve.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>