RGFnZWxpamtzIG5pZXV3cyB8IEJDSCBCbG9jayBSZXdhcmQgSGFsdmluZyB2b2x0b29pZDsgQlRDIFNwb3QgRVRGJ3MgaGFkZGVuIGVlbiBuZXR0b3N0b3J0aW5nIHZhbiAkMTE0TTsgU0VDIHZlcnpvY2h0IG9tIHB1YmxpZWtlIG9waW5pZSBvdmVyIGRlIFNwb3QgRXRoZXJldW0gRVRGJ3MgdmFuIEdyYXlzY2FsZSwgQml0d2lzZSBlbiB

2024-04-04, 03:48

<p><img src="https://gimg2.gateimg.com/image/article/17122024521_5.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20halvering20van20BCH20blok20beloningen20is20voltooid20Op20320april20hadden20Bitcoin20spot20ETFs20een20nettostroom20van2011420miljoen20De20Amerikaanse20SEC20vroeg20om20publieke20opinie20over20de20spot20Ethereum20ETFs20van20Grayscale20Bitwise20en20Fidelity20en20Ethereum20onderzoekers20publiceerden20het20EIP762320onderzoeksrapport12378"><a name="Crypto Dagelijkse Samenvatting: De halvering van BCH blok beloningen is voltooid. Op 3 april hadden Bitcoin spot ETFs een nettostroom van $114 miljoen. De Amerikaanse SEC vroeg om publieke opinie over de spot Ethereum ETFs van Grayscale, Bitwise en Fidelity, en Ethereum onderzoekers publiceerden het EIP-7623 onderzoeksrapport." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De halvering van BCH blok beloningen is voltooid. Op 3 april hadden <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETFs een nettostroom van $114 miljoen. De Amerikaanse SEC vroeg om publieke opinie over de spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETFs van Grayscale, Bitwise en Fidelity, en Ethereum onderzoekers publiceerden het EIP-7623 onderzoeksrapport.</h2><p>De Silk Road-portemonnee, gecontroleerd door het Amerikaanse ministerie van Justitie, heeft 2.000 BTC overgemaakt naar Coinbase Prime.</p>
<p>Volgens de monitoring van HODL15 Capital had BlackRock IBIT op 3 april een nettostroom van $42 miljoen, Fidelity FBTC had een nettostroom van $117 miljoen, Bitwise BITB had een nettostroom van $23 miljoen, Franklin EZBC had een nettostroom van $4 miljoen, WisdomTree BTCW had een nettostroom van $3,1 miljoen, ARKB en VanEckHODL hadden geen instroom/uitstroom van fondsen, en Grayscale GBTC had een nettostroom van $75 miljoen.</p>
<p>De BCH blokbeloning is gehalveerd en teruggebracht naar 3.125 BCH.</p>
<p>Het Wormhole-protocol vrijgegeven roadmap is gericht op verdere decentralisatie door de lancering van W-tokens om het eerste cross-chain governance systeem in de branche op te zetten. De W-token zal eerst worden gelanceerd als een SPL-token op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain, gebruikmakend van het high-performance ecosysteem van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> om W te voorzien van een basis van schaalbaarheid, lage handelskosten en snelle verwerkingstijd. Vervolgens wordt W uitgebreid naar alle EVM-ketens die verbonden zijn met Wormhole via Wormhole Native Token Transfer (NTT), waardoor W naadloos kan worden overgezet tussen ketens met behoud van zijn unieke praktische toepasbaarheid op het Wormhole-platform.</p>
<p>Volgens bronnen aangehaald door Bloomberg is cryptoinvesteringsmaatschappij Paradigm in gesprek met investeerders om $750 miljoen tot $850 miljoen op te halen voor een nieuw fonds. Als deze transactie wordt voltooid, zal het fonds het grootste worden in de branche sinds de cryptobeermarkt in 2022.</p>
<p>Volgens The Block, volgens de ingediende documenten, zoekt de Amerikaanse Securities and Exchange Commission (SEC) naar de mening van het publiek over een paar <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF’s, waaronder Fidelity’s Ethereum Fund, Grayscale Ethereum Trust en Bitwise Ethereum Trust.</p>
<p>Onderzoekers van Ethereum hebben een rapport uitgebracht over EIP-7623, met als doel de kosten voor oproepgegevens te verhogen voor transacties gericht op DA.</p>
<h2 id="h2-Markttrends20BTC20blijft20consolideren20op20een20hoog20niveau20en20het20Baseecosysteem20doorbreekt20de20omsingeling626242"><a name="Markttrends: BTC blijft consolideren op een hoog niveau, en het Base-ecosysteem doorbreekt de omsingeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC blijft consolideren op een hoog niveau, en het Base-ecosysteem doorbreekt de omsingeling</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Bitcoin (BTC) kent momenteel een lichte schommeling en zweeft rond de $65.000 - 66.000, en de algehele markt vertoont een hersteltrend na een sterke overbought. Ethereum (ETH) blijft in een passieve en zwakke positie. De recente markthype is verschoven van het Solana-ecosysteem naar het Base-ecosysteem, met memes zoals BRETT en DEGEN die het Base-ecosysteem uit de markt hebben gedreven. Wat betreft macro-economie, steeg en daalde de Amerikaanse aandelenmarkt gisteren en was er ook sprake van hoge volatiliteit. Het is belangrijk om aandacht te besteden aan het banenrapport en de werkloosheidscijfers van morgen.</p>
<h3 id="h3-Markt20Hotspots940375"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Het Solana-ecosysteem handhaaft een opwaartse trend: Jito- en Jupiter-tokens op de Solana-keten zijn onbevreesd voor de algehele marktdaling en stellen keer op keer nieuwe historische hoogtepunten in. Daarnaast moeten investeerders op de hoogte zijn van het risico van RUGPULL in de CONDOM van Meme-munten op de Solana-keten.</p>
<p>De populariteit van Base Chain blijft hoog: Base Chain is begonnen de Solana Chain meme-rage over te nemen, met zowel de opkomende MFER, die in 6 uur tijd 100 keer is gestegen. De toonaangevende bedrijven DEGEN en BRETT handhaven hun momentum op de markt. Op dit moment nadert het aantal adressen op de Base Chain de 70 miljoen, met een TVL van $3,86 miljard, waarmee het zich qua transactievolume onder de top L2 bevindt.</p>
<p>BSV-halvering: Gisteren voltooide BCH de halvering en werd de blokbeloning verlaagd naar 3,125 BCH. Onlangs heeft BCH een aanzienlijke stijging gezien als gevolg van marktspeculatie, en op de 12e van deze maand zal BSV worden gehalveerd, wat mogelijk de aandacht van de markt zal trekken.</p>
<p>De marktwaarde van de nieuwe valuta ENA heeft de $1 miljard overschreden: Ethena airdrops zijn de heetste trend geworden in het DeFi-veld. Momenteel heeft de marktwaarde van ENA de $1 miljard grens overschreden, en de markt speculeert dat het de volgende LUNA zou kunnen worden.</p>
<p>Over het algemeen zijn marktkrachtpunten nog steeds geconcentreerd in sectoren zoals het Solana Ecosysteem, het Base Ecosysteem en halvering. Beleggers moeten deze krachtpunten nauwlettend volgen en hun beleggingsstrategieën tijdig aanpassen op basis van de marktomstandigheden, terwijl ze voorzichtig reageren op marktrisico’s.</p>
<h2 id="h2-Macro20De20Federal20Reserve20handhaaft20een20voorzichtige20houding20ten20opzichte20van20renteverlagingen20en20houdt20vanavond20nauwlettend20toezicht20op20de20nietagrarische20loonlijst20en20werkloosheidscijfers919838"><a name="Macro: De Federal Reserve handhaaft een voorzichtige houding ten opzichte van renteverlagingen en houdt vanavond nauwlettend toezicht op de niet-agrarische loonlijst en werkloosheidscijfers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve handhaaft een voorzichtige houding ten opzichte van renteverlagingen en houdt vanavond nauwlettend toezicht op de niet-agrarische loonlijst en werkloosheidscijfers</h2><p>Federal Reserve-voorzitter Powell zei woensdag dat de sterker dan verwachte economische activiteit dit jaar de algemene verwachting van de Fed dat een daling van de inflatie de Fed in staat zal stellen de rente dit jaar te verlagen, niet heeft veranderd.</p>
<p>Ten eerste is volgens gegevens die woensdag zijn vrijgegeven, het aantal ADP-banen in de Verenigde Staten in maart aanzienlijk gestegen, met 184.000. Dit aantal is niet alleen hoger dan de oorspronkelijke voorspelling van de markt van 148.000, maar ook hoger dan de eerder aangekondigde en herziene 155.000. Het is vermeldenswaard dat US private ondernemingen vorige maand hun grootste wervingsgroei sinds juli hebben geregistreerd, gedreven door de sterke groei van de vrijetijds- en hotelindustrie, wat wijst op de sterke prestaties van de huidige arbeidsmarkt.</p>
<p>Ondertussen heeft de groei van de werving in de recreatie- en hotelindustrieën een sterke ondersteuning geboden voor de algehele werving van particuliere ondernemingen, wat waarschijnlijk nauw verband houdt met de economische herstart en het toegenomen consumentenvertrouwen. Het herstel van deze industrieën zal ongetwijfeld een positief en verstrekkend effect hebben op de algehele arbeidsmarkt.</p>
<p>Echter, gezien de huidige economische situatie en marktverwachtingen, lijkt de mogelijkheid van een bearish vooruitzicht hoog. Het is mogelijk dat de vrijgegeven niet-agrarische gegevens de verwachte 200.000 mensen zullen overtreffen en mogelijk zelfs het bereik van 220.000 tot 250.000 mensen zullen bereiken. De markt wacht nog steeds op de aankomende vrijgave van niet-agrarische en werkloosheidsgegevens morgenavond, wat de markttrend en of het zal blijven dalen of een tegenaanval zal ondergaan direct zal bepalen.</p>
<p>Specifiek is de voorafwaarde van de niet-agrarische payroll 275.000 mensen, terwijl de marktverwachting 200.000 mensen is. Als de werkelijke gegevens de verwachtingen ver overtreffen, vormt dit een bearish signaal; daarentegen, als het lager is dan verwacht, zal het de markt ten goede komen.</p>
<p>De vorige en verwachte werkloosheidswaarden zijn 3,90%. Als de werkelijke gepubliceerde gegevens lager zijn dan verwacht, dat wil zeggen een daling van de werkloosheid, dan wordt dit beschouwd als een bearish signaal; daarentegen, als het de verwachtingen overtreft, zal het de markt ten goede komen.</p>
<p>Over het algemeen toont het beleid van de Federal Reserve momenteel een voorzichtige en afwachtende houding. Voorzitter Powell heeft in meerdere toespraken benadrukt dat er meer bewijs nodig is om aan te tonen dat de inflatie gestaag afneemt voordat er besloten wordt tot een renteverlaging. Hij erkent dat er recentelijk een stijging is geweest in de inflatiegegevens, maar gelooft dat dit slechts een tijdelijke fluctuatie is en niet genoeg om de omkering van de inflatietrend te bepalen. Powell heeft geprobeerd een balans te vinden tussen het vermijden van de mogelijkheid dat te snelle renteverlagingen de inflatie weer aanwakkeren en te lang wachten, wat druk op de economie kan leggen.</p>
<p>De markt verwachtte oorspronkelijk dat de Federal Reserve in juni zou beginnen met het verlagen van de rente, maar beleggers twijfelen nu, mede door de voorzichtige verklaringen van functionarissen van de Federal Reserve. De observatietool voor de rente van de Federal Reserve van de Chicago Mercantile Exchange laat zien dat de markt een afname van de waarschijnlijkheid verwacht dat de Fed de rente in juni zal verlagen.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te delen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen bij schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>