RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBjb25zb2xpZGVlcmRlIG9wIGVlbiBob29nIG5pdmVhdSBib3ZlbiAkNzBLOyBKUE1vcmdhbiBDaGFzZSB2ZXJrbGFhcmRlIGRhdCBlZW4gJ25lZXJnYW5nJyBpbiBkdXJma2FwaXRhYWwgdm9vciBjcnlwdG8gZWVuIG5lZXJ3YWFydHMgcmlzaWNvIHZvcm10OyBCb3VuY2ViaXQgbGFuY2VlcnQgQlR

2024-04-12, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/171289300212.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20consolideert20op20een20hoog20niveau20boven2070K20JPMorgan20Chase20verklaarde20dat20een20neergang20in20crypto20durfkapitaal20een20neerwaarts20risico20vormt20Bouncebit20zal20BTCgesteunde20stablecoins20lanceren614625"><a name="Crypto Dagelijkse Samenvatting: BTC consolideert op een hoog niveau boven $70K; JPMorgan Chase verklaarde dat een ‘neergang’ in crypto durfkapitaal een neerwaarts risico vormt; Bouncebit zal BTC-gesteunde stablecoins lanceren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC consolideert op een hoog niveau boven $70K; JPMorgan Chase verklaarde dat een ‘neergang’ in crypto durfkapitaal een neerwaarts risico vormt; Bouncebit zal BTC-gesteunde stablecoins lanceren</h2><p>Laten we eerst eens kijken naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handelsactiviteit van ETF’s. Volgens gegevens van HODL15Capital had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 11 april een uitstroom van $120 miljoen aan fondsen; Ondertussen ontving BlackRock IBTC een instroom van $192 miljoen, Fidelity FBTC ontving een instroom van $5 miljoen, Bitwise BITB ontving een instroom van $11 miljoen en Valkyrie BRRR ontving een instroom van $8 miljoen. De algehele netto-instroom was $91 miljoen, met een netto-instroom van 1.294 BTC’s.</p>
<p>Worldcoin meldde dat de World App meer dan 10 miljoen gebruikers heeft, met dagelijkse activiteit van 2 miljoen en een totaal handelsvolume van meer dan 70 miljoen in portefeuilles. Eerder, in december 2023, had de World App van Worldcoin meer dan 5 miljoen gebruikers, waarvan 1 miljoen gebruikers het elke week gebruikten, met dagelijkse en maandelijkse activiteit van respectievelijk 350.000 en 1,7 miljoen. Dit betekent ook dat de World app een significante groei in gebruikers en nieuwe transactieactiviteiten heeft gezien in het afgelopen kwartaal.</p>
<p>De moeilijkheid van Bitcoin-mining is met 3,92% toegenomen tot 86,39 T, waarmee een nieuw historisch hoogtepunt is bereikt. Het is minder dan tien dagen geleden sinds de huidige ronde van Bitcoin-halvering. Volgens on-chain gegevens wordt verwacht dat BTC op 20 april een halvering zal ondergaan en de huidige blockbeloning zal worden gehalveerd van 6,5 BTC tot 3,25 BTC.</p>
<p>Robert Kiyosaki, auteur van ‘Rich Dad Poor Dad’, plaatste op sociale media: ‘Cathie Wood garandeert dat Bitcoin $2,3 miljoen per munt zal bereiken. Geloof ik haar? Ja, dat doe ik. Ze kan fout zitten. Dus wat? De belangrijkste vraag is wat jij gelooft? Belangrijker nog, hoeveel Bitcoin heb je? Ik geloof ook dat Bitcoin $2,3 miljoen zal bereiken.’</p>
<h2 id="h2-Markttrends20BTCconsolidatie20op20hoog20niveau20altcoins20vallen20over20het20algemeen679745"><a name="Markttrends: BTC-consolidatie op hoog niveau, altcoins vallen over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC-consolidatie op hoog niveau, altcoins vallen over het algemeen</h2><p>Bitcoin (BTC) consolideert op een hoog niveau, terwijl Altcoins over het algemeen dalen. Hoewel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De wisselkoers van Gate.io ten opzichte van Bitcoin is versterkt, maar heeft niet geleid tot een sterke opwaartse trend voor Altcoins. Sinds het begin van dit jaar zijn er regelmatig nieuwe munten opgedoken, zijn markthotspots verspreid en zijn fondsen ook verspreid, waardoor het moeilijk is om een duidelijke samenhangende kracht te vormen.</p>
<p>Met betrekking tot de macro-economie is de Amerikaanse aandelenmarkt hersteld, maar de Federal Reserve’s Collins verklaarde dat renteverlagingen mogelijk moeten worden uitgesteld of verminderd dit jaar, wat bijdraagt aan de onzekerheid op de markt.</p>
<h3 id="h3-Markt20Hotspots23040"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Public-chain TON blijft stijgen: TON prijzen blijven stijgen, met een huidige koers van $7.12, een stijging van 6% in 24 uur. Ton maakte TON-tokenairdrops actief op ketenhandelaren, wat de ontwikkeling van het ecosysteem stimuleerde, en veel Ton-ecosysteemtokens zagen een aanzienlijke groei. Onlangs heeft Ton Eco’s <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> native smartphone, Universal Phone, zijn eerste ronde van pre-sales voltooid. De gemeenschap heeft de Universal Phone vergeleken met de SAGA-telefoon die is uitgegeven door <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, en er wordt verwacht dat er veel Ton tokens worden uitgedeeld voor deze telefoon.</p>
<p>BTC ecosysteemgerelateerde tokens hebben uitstekend gepresteerd: Rune-gebaseerde tokens hebben het goed gedaan, met frequente Bitcoin on-chain handelsactiviteiten en BTC gasvergoedingen tot 150 sats.</p>
<p>Bouncebit steeg als gevolg van nieuws over institutionele investeringen: het steeg gisteren kortstondig met 20%, en momenteel is de prijs van AUDION terugglen tot ongeveer $21. Bouncebit is van plan om een stablecoin-bedrijf te lanceren dat vergelijkbaar is met Ethena, en dat zal gebaseerd zijn op Bitcoin-staking.</p>
<p>Hoewel Bitcoin blijft consolideren, blijven enkele hete onderwerpen in de markt. Beleggers moeten de marktveranderingen en macro-economische gegevens nauwlettend in de gaten houden en flexibel hun investeringsstrategie aanpassen. TON blijft stijgen en BTC-ecosysteemgerelateerde tokens presteren goed, maar de halvering is aanstaande. Beleggers moeten letten op marktrisico’s en voorzichtig zijn bij besluitvorming. Ondertussen heeft Bouncebit een korte termijn stijging doorgemaakt en is daarna teruggetrokken vanwege de impact van nieuws over institutionele investeringen. De prestatie na de lancering van zijn stablecoin business heeft nog steeds aandacht nodig.</p>
<h2 id="h2-Macro20PPI20tijdelijk20schort20inflatiezorgen20op20goud20blijft20historische20hoogtepunten20bereiken102029"><a name="Macro: PPI tijdelijk schort inflatiezorgen op, goud blijft historische hoogtepunten bereiken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: PPI tijdelijk schort inflatiezorgen op, goud blijft historische hoogtepunten bereiken</h2><p>Uit gegevens blijkt dat de producentenprijsindex (PPI) in maart in de Verenigde Staten de grootste jaar-op-jaar stijging in 11 maanden registreerde, maar sommige van de deelonderdelen lieten relatief gematigde stijgingen zien. Het Amerikaanse ministerie van Arbeid kondigde donderdag aan dat de PPI in maart op jaarbasis met 2,1% is gestegen. Elke maand, na een aanzienlijke stijging in februari, steeg de PPI in maart met 0,2%, lager dan de verwachte 0,3%.</p>
<p>Uit PPI-gegevens blijkt ook dat de kosten van diensten de afgelopen drie maanden zijn gestegen, wat de belangrijkste reden is gebleken voor hoge inflatie, waardoor handelaren hun verwachtingen over wanneer de Federal Reserve de rente zal verlagen, hebben verlaagd.</p>
<p>De Amerikaanse aandelenmarkt sloot donderdag af, waarbij de Dow Jones Industrial Average bijna vlak sloot, gedreven door een herstel van techreuzen. De S&amp;P 500 index steeg met 0,74%, terwijl de Nasdaq met 1,68% steeg. Het Amerikaanse PPI-rapport van maart, dat donderdag werd vrijgegeven, zorgde voor een positief marktsentiment, iets lager dan verwacht. De dag ervoor drukte de sterke CPI van maart in de Verenigde Staten de marktverwachtingen voor een renteverlaging door de Fed.</p>
<p>Bij het sluiten daalde de Dow Jones Industrial Average met 2,43 punten, een daling van 0,01%, tot 38.459,08 punten; De S&amp;P 500-index steeg met 38,05 punten, of 0,74%, tot 5.198,69 punten; En de Nasdaq Composite Index steeg met 271,84 punten, of 1,68%, tot 16.442,20 punten.</p>
<p>De leiders van de biljoen-dollar club, NVDA.US en Apple (AAPL.US), stegen met meer dan 4%. Alphabet (GOOGL.US) steeg meer dan 2%, met een marktwaarde van bijna $2 biljoen, terwijl Amazon Inc. (AMZN.US) met 1.7% steeg en een historisch hoogtepunt bereikte.</p>
<p>Goud heeft een nieuw historisch hoogtepunt bereikt, waarbij het spotgoud de vorige hoogte van $2.365,25 per ounce doorbrak en kort over de $2.370 per ounce grens heen ging, en blijft doorgaan om een nieuw historisch hoogtepunt te bereiken. COMEX-futures voor juni stegen met 1,03% tot $2.372,7 per ounce en vestigden daarmee een nieuw sluitingsrecord.</p>
<p>De voorzitter van de New York Fed, John Williams, verklaarde dat de Fed “aanzienlijke vooruitgang” heeft geboekt bij het bereiken van een beter evenwicht tussen inflatie en werkgelegenheidsdoelstellingen, maar niet gehaast is om de rente op korte termijn te verlagen. Na een evenement in New York vertelde Williams aan de media dat de inflatie “nog ver weg” is van het bereiken van het streefcijfer van 2% van de Federal Reserve.</p>
<p>Hij benadrukte dat het huidige monetaire beleid in een goede staat verkeert en dat de arbeidsmarkt sterk blijft. Williams zei: ‘Er is geen behoefte aan ingrijpende beleidswijzigingen op korte termijn, en naarmate we meer gegevens verzamelen, zullen we kunnen beoordelen of we voldoende vertrouwen hebben in een terugkeer van het inflatiepercentage naar 2%.’ Williams verwacht dat het inflatiepercentage geleidelijk zal blijven terugkeren naar 2%, maar het proces zal niet soepel verlopen.</p>
<p>Voorzitter van de Boston Fed, Collins, verklaarde dat de urgentie van renteverlagingen nu lager is dan eerder dit jaar, en het risico van monetaire beleidsverkrapping is verdwenen.</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 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>