RGFnZWxpamtzIG5pZXV3cyB8IFBvd2VsbCB0b29udCBlZW4gbGF1d2UgdmVydHJvdXdlbiBpbiBtb2dlbGlqa2UgcmVudGV2ZXJsYWdpbmdlbiB2b29yIGRpdCBqYWFyLiA5IEJpdGNvaW4gRVRGJ3MgdmVybWluZGVyZGVuIGdpc3RlcmVuIGh1biBCaXRjb2luLWFjdGl2YSBtZXQgMS45NTAgQlRD

2024-05-02, 04:02

<p><img src="https://gimg2.gateimg.com/image/article/17146223061_0.png" alt=""></p>
<p>Crypto Dagelijkse Samenvatting: Powell toont lauwe vertrouwen in mogelijke renteverlagingen voor dit jaar. 9 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s hebben gisteren hun Bitcoin-activa met 1.950 BTC verminderd. <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> heeft zijn Bitcoin-bezittingen dit kwartaal met 8.900 BTC verhoogd.</p>
<p>Volgens de laatste gegevens van CME’s ‘Fed Watch’ is de Federal Reserve zeer waarschijnlijk om de rentetarieven stabiel te houden in juni, met een waarschijnlijkheid van 90,9%, terwijl de kans op een renteverlaging van 25 basispunten op 9,1% ligt. Wat betreft de langere termijn vooruitzichten, geven de kansen de voorkeur aan de Fed die de huidige tarieven handhaaft tot augustus met een waarschijnlijkheid van 72,1%, met een kans van 26% op een cumulatieve verlaging van 25 basispunten en een kans van 1,9% op een meer agressieve verlaging van in totaal 50 basispunten.</p>
<p>De laatste FOMC-verklaring geeft aan dat de Federal Reserve van plan is om vanaf juni zijn inspanningen om het balanstotaal te verminderen te vertragen. De Fed is van plan de vermindering van Amerikaanse schatkistreserves te verlagen van $ 60 miljard naar $ 25 miljard per maand, terwijl de vermindering van met hypotheek gedekte effecten op $ 35 miljard per maand wordt gehouden. Ondanks het niet halen van zijn inflatiedoel van 2%, benadrukt de Fed de noodzaak van voortdurende verbeteringen van de inflatie voordat er sprake kan zijn van renteverlagingen. De inflatie is gematigd, maar blijft op een hoog niveau. Het besluit om de huidige rentetarieven te handhaven werd unaniem overeengekomen door alle commissieleden te midden van een onduidelijke economische outlook en verhoogde waakzaamheid over inflatoire druk.</p>
<p>Monitoring door Lookonchain onthult dat op 1 mei Grayscale’s GBTC zijn <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> houdingen met 404 eenheden verminderd, ter waarde van ongeveer USD 23,2 miljoen, waardoor de huidige holdings op 296.714 Bitcoins blijven, ter waarde van ongeveer USD 17 miljard. Daarnaast heeft een collectief van negen Bitcoin ETF’s, waaronder Grayscale, Bitcoin-activa met 1.950 Bitcoins verminderd, wat overeenkomt met een waarde van USD 111,93 miljoen. Opmerkelijk is dat BlackRock’s IBTC zijn Bitcoin-accumulatie heeft onderbroken, waarbij gedurende vijf opeenvolgende dagen geen toename van zijn Bitcoin-holdings is waargenomen.</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft zijn Bitcoin-reserves versterkt met 8.900 BTC sinds het laatste kwartaal, en bezit nu in totaal 75.353 BTC ter waarde van ongeveer $4,4 miljard. Dit vertegenwoordigt 0,38% van de totale circulerende voorraad van Bitcoin.</p>
<p>AaveLabs heeft gisteren het V4 roadmap governance voorstel uitgebracht, dat gepland staat om uitgebracht te worden in midden-2025.</p>
<p>Op 2 mei organiseerde het Gatsby Center for Computational Neuroscience aan het University College London de London Decentralized AI Summit. Het evenement bracht tal van specialisten uit de industrie samen die diepgaande discussies voerden over de toekomst van gedecentraliseerde kunstmatige intelligentie. Keynotes en presentaties werden gegeven over uiteenlopende onderwerpen, waaronder de gedecentraliseerde cloud computing-infrastructuur Trias, het gedistribueerde AI-computernetwerk Gensyn en de AI-privacyoplossing Flock.io, onder andere.</p>
<p>Het cross-chain interoperabiliteitsprotocol LayerZero heeft aangekondigd op X dat Snapshot #1 is voltooid en er binnenkort meer informatie zal worden bekendgemaakt.</p>
<p>Bronnen die bekend zijn met de zaak melden dat durfkapitaalfirma a16z heeft geïnvesteerd in <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> De aankoop van ‘s inheemse OP-tokens wordt gewaardeerd op ongeveer 90 miljoen dollar. De investering is gestructureerd met een vestigingsschema van twee jaar. Op dit moment hebben vertegenwoordigers van a16z nog geen commentaar gegeven in reactie op vragen over de transactie. Op dezelfde manier heeft een woordvoerder van <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> geen enkele verklaring afgelegd over de investering.</p>
<h2 id="h2-Markttrends20Terwijl20Bitcoin20dalende20is20toont20de20Altcoinsector20opmerkelijke20veerkracht20te20midden20van20de20marktschommelingen411923"><a name="Markttrends: Terwijl Bitcoin dalende is, toont de Altcoin-sector opmerkelijke veerkracht te midden van de marktschommelingen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Terwijl Bitcoin dalende is, toont de Altcoin-sector opmerkelijke veerkracht te midden van de marktschommelingen.</h2><p><strong>Algemene trend:</strong><br>Bitcoin (BTC) heeft gisteren een aanzienlijke daling doorgemaakt, waarbij het zakte van ongeveer $60.600 naar ongeveer $50.500, en tijdelijke steun vond bij het cruciale 120-daags voortschrijdend gemiddelde - een niveau dat vaak wordt beschouwd als een scheidslijn tussen optimistisch en pessimistisch sentiment. Momenteel vertoont Bitcoin tekenen van zwakte, maar de bredere altcoin-markt heeft een vertraging in de daling gezien, wat wijst op opkomend optimistisch momentum nu de golf van liquidaties van long-posities zijn einde nadert. Ondanks een vertraging in de Amerikaanse crypto-ETF’s heeft de Hong Kong ETF meer dan $200 miljoen aan instroom gezien, genoeg om de uitstroom uit de Amerikaanse ETF’s te compenseren. Gegevens tonen aanhoudende nettostromen uit Amerikaanse ETF-fondsen aan, waarbij opmerkelijke entiteiten zoals BlackRock IBTC en Fidelity FBTC hun Bitcoin-posities gedurende opeenvolgende dagen niet hebben vergroot. Desalniettemin heeft de recente vergadering van de Federal Reserve de marktonzekerheid verminderd, en met miners die terughoudendheid tonen om hun Bitcoin-posities te verkopen, in combinatie met een stijgende vraag naar stablecoins, kan Bitcoin beperkt potentieel hebben voor verdere dalingen.</p>
<p><strong>Markt Hotspots:</strong> <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> EcologieSector: Het Solana-ecosysteem blijft de sector boeien met zijn dynamische groei en innovatie. Het concept van Restaking binnen deze sector heeft veel aandacht getrokken vanwege het potentieel om grote liquiditeit vrij te maken. Onlangs hebben zes projecten, waaronder Jito, plannen aangekondigd om re-stakingdiensten op het Solana-netwerk te introduceren. Bovendien hebben de lancering van het op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> gebaseerde liquiditeitsbeheerprotocol Kamino (KMNO) en het vastgoedinitiatief Parcl (PRCL) opmerkelijke interesse van investeerders opgewekt. Drift, een prominente DEX-derivatenplatform binnen het Solana-ecosysteem, heeft ook de lancering van een abonnementstoegangscontrole op het X-platform onthuld, een evenement dat zeer wordt verwacht en naar verwachting aanzienlijke aandacht zal trekken bij de notering van de coin.</p>
<p>OP: Optimism (OP), bekend om zijn kostenefficiëntie en hoge transactiesnelheid als een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Layer 2 (L2) oplossing heeft zijn inheemse OP-token met 10% zien stijgen te midden van een bredere marktdaling gisteren. Deze waardestijging wordt toegeschreven aan marktspeculatie dat het durfkapitaalbedrijf a16z van plan is om gedurende een periode van twee jaar ongeveer $90 miljoen te investeren in OP-tokens. Deze prestatie heeft Optimism gepositioneerd als een van de opvallende spelers in de recente L2-ruimte.</p>
<p>W: Wormhole (W), een veelzijdig berichtenprotocol dat interchain-communicatie vergemakkelijkt, heeft een opmerkelijke veerkracht getoond in een dalende markt, vergelijkbaar met Optimism (OP). Het Wormhole-team heeft onlangs zijn uitgebreide ecosysteemstrategie onthuld, die drie belangrijke initiatieven omvat: het Wormhole Accelerator-programma, een cross-chain ecologisch fonds van $50 miljoen en het xGrant-plan. Daarnaast heeft het project zijn roadmap voor het integreren van Zero-Knowledge (ZK) technologie bekendgemaakt.</p>
<p>ZETA: ZetaChain (ZETA) is een allesomvattend smart contract platform dat in staat is om universele smart contracts en berichtenverkeer over verschillende blockchains mogelijk te maken. Net als Wormhole (W) valt ZetaChain binnen de sector van de cross-chain interoperabiliteit, die recentelijk veel marktinteresse heeft gekregen. Als mijlpaal heeft ZetaChain met succes zijn eerste fase snapshot voltooid en Zetahub geïntroduceerd, dat dient als een toegangspoort tot het XP en ZetachainApp-ecosysteem. Na deze ontwikkelingen heeft ZetaChain een snelle opleving doorgemaakt, waarbij de waarde in de afgelopen 25 uur met bijna 8,5% is gestegen.</p>
<p>Terwijl de prijs van Bitcoin blijft dalen, hebben sectoren die ooit aanzienlijke welvaart creëerden, zoals MEME, DePIN en AI, een afname van het enthousiasme gezien. Deze afkoeling kan de weg vrijmaken voor een verschuiving van de marktfocus naar sectoren die hun veerkracht hebben behouden, zoals cross-chain interoperabiliteit en Layer 2-technologieën, vooral nu de markt probeert zijn dynamiek te herstellen. Te midden van een inkrimping van de macro-economische liquiditeit is speculatieve investeringen voorzichtiger geworden, waardoor nieuwe conceptsectoren die bekend staan om hun hoge rendementen worden overschaduwd door meer gevestigde, mainstream projecten.</p>
<h2 id="h2-Macro20De20Federal20Reserve20handhaaft20haar20toewijding20aan20een20beleid20van20hoge20rentetarieven20en20suggereert20dat20renteverlagingen20mogelijk20worden20uitgesteld44495"><a name="Macro: De Federal Reserve handhaaft haar toewijding aan een beleid van hoge rentetarieven en suggereert dat renteverlagingen mogelijk worden uitgesteld." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve handhaaft haar toewijding aan een beleid van hoge rentetarieven en suggereert dat renteverlagingen mogelijk worden uitgesteld.</h2><p>Om 2 uur ‘s ochtends op 2 mei, Hong Kong tijd, heeft de Federal Reserve haar besluit aangekondigd om de federale fondsrente stabiel te houden binnen het 5,25% tot 5,50% doelbereik. Dit markeert de zesde opeenvolgende pauze in renteverhogingen sinds september van het voorgaande jaar, in lijn met de verwachtingen van de markt.</p>
<p>Tijdens de daaropvolgende persconferentie gaf voorzitter van de Federal Reserve, Jerome Powell, aan dat de volgende stap in de rentetarieven ‘onwaarschijnlijk’ een verhoging zal zijn, waardoor zorgen over aanhoudend hoge inflatie werden verlicht. Powell erkende de aanzienlijke vooruitgang die de Fed heeft geboekt bij het beteugelen van de inflatie, maar benadrukte opnieuw de verhoogde waakzaamheid van de centrale bank voor inflatoire dreigingen, waarbij de voortdurende toewijding aan het terugbrengen van de inflatie naar het 2%-doel werd benadrukt.</p>
<p>Belangrijk is dat de Federal Reserve een strategie heeft onthuld om zijn inspanningen voor kwantitatieve verstrakking (QT) te verminderen. Vanaf juni is de Fed van plan het tempo van de vermindering van Amerikaanse schatkistpapieren te vertragen van $60 miljard per maand naar $25 miljard per maand, terwijl de maandelijkse vermindering van hypotheekgedekte effecten (MBS) doorgaat tegen het huidige tempo van $35 miljard.</p>
<p>De beslissing van de Federal Reserve om de vermindering van haar balans te vertragen, wordt gezien als een gematigde versoepeling van het monetair beleid. Hoewel de markt over het algemeen had verwacht dat de vermindering van het balansblad van de Fed geleidelijk zou plaatsvinden, was de daadwerkelijke omvang van de vermindering die aangekondigd werd door de Federal Reserve groter dan verwacht.</p>
<p>Feitelijk heeft Fed-voorzitter Powell tijdens de persconferentie een ‘duifachtige’ toon overgebracht, waarbij hij aangaf bereid te zijn om het monetaire beleid voorzichtig te verschuiven door de vermindering van de schaal van kwantitatieve verkrappingmaatregelen.</p>
<p>De dovish verklaring van voorzitter Powell heeft een positieve reactie van de Amerikaanse aandelenmarkt teweeggebracht, waarbij alle drie belangrijke indexen - de Dow Jones Industrial Average, de S&amp;P 500 en de Nasdaq Composite - een stijging doormaakten. Uiteindelijk sloot de Dow Jones met een bescheiden stijging, terwijl de S&amp;P 500 en de Nasdaq Composite lichte dalingen zagen. Bitcoin-gerelateerde aandelen vertoonden een gemengde prestatie in lijn met de ingetogen marktpositie van Bitcoin, en het blijft verder afwachten hoe de markt zich zal ontwikkelen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>