RGFnZWxpamtzIG5pZXV3cyB8IENlbHNpdXMgc3R1dXJkZSBtZWVyIGRhbiA0NUsgRVRIIG5hYXIgbWVlcmRlcmUgQ0VYczsgRWVuIEVUSC13YWx2aXMgd29uICQ1MDBLIGFhbiBrb3J0ZSB0ZXJtaWpuIHdpbnN0ZW47IEV0aGVyZXVtIERlbmNodW4gVXBncmFkZSB6YWwgYWwgaW4gZmVicnVhcmkgd29yZGVuIGdlbGFuY2VlcmQ=

2024-01-26, 03:29

<p><img src="https://gimg2.gateimg.com/image/article/17062396991_21.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Celsius20heeft20meer20dan204500020ETH20overgedragen20Denchunupgrade20kan20al20eind20februari20worden20gelanceerd208783"><a name="Crypto Dagelijkse Samenvatting: Celsius heeft meer dan 45.000 ETH overgedragen, Denchun-upgrade kan al eind februari worden gelanceerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Celsius heeft meer dan 45.000 ETH overgedragen, Denchun-upgrade kan al eind februari worden gelanceerd</h2><p>Op de negende handelsdag van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Bij spot ETF’s was er een nettouitstroom van $158 miljoen. Daarvan was de uitstroom van GBTC $429,3 miljoen, de instroom van IBIT (BlackRock) $66,2 miljoen en de instroom van FBTC (Fidelity) $125,7 miljoen. Bovendien heeft Grayscale GBTC volgens Lookonchain monitoring op 24 januari zijn bezit van 13.179 BTC verminderd (ter waarde van ongeveer $529,2 miljoen). De overige 8 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s hebben hun bezit met 8.251 BTC verhoogd (ter waarde van ongeveer $331,3 miljoen), waarvan Fidelity zijn bezit met 4.023 BTC heeft verhoogd (ter waarde van ongeveer $161,5 miljoen).</p>
<p>Op 25 januari toonden officiële gegevens van BlackRock aan dat op 24 januari 2024 zijn spot Bitcoin ETF IBIT 45.668,08260 BTC bezat, met een marktwaarde van ongeveer $ 1.833.605.029,01, een stijging van ongeveer 1.663 BTC’s ten opzichte van 44.004,5231 BTC op 23 januari.</p>
<p>Gisteren heeft de Amerikaanse overheid een mededeling uitgebracht waarin plannen worden bekendgemaakt om 2875 Bitcoins te verkopen die in beslag zijn genomen van de Silk Road dark web drugshandelaar Ryan Farace en voormalig <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> Dienstagent Shaun Bridges. Deze Bitcoins zijn momenteel ongeveer $133 miljoen waard. Ryan Farace werd vorig jaar in Maryland veroordeeld tot 54 maanden gevangenisstraf wegens samenzwering om geld wit te wassen. Shaun Bridges was lid van de Silk Road Task Force en werd in 2015 veroordeeld tot zes jaar gevangenisstraf wegens zijn betrokkenheid bij het onderzoek van de Amerikaanse overheid naar de Silk Road. De Amerikaanse overheid heeft verklaard dat zij van in beslag genomen eigendommen wil afkomen volgens de instructies van de Amerikaanse procureur-generaal.</p>
<p>Laatste voortgang over <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>: Op 26 januari, volgens de monitoring van Spot on Chain, zijn er in de afgelopen 8 uur 45956 ETH (ter waarde van $1,02 miljard) naar meerdere CEX-adressen verzonden naar het Celsius-adres. Daarvan zijn 305254 ETH (ongeveer $674 miljoen) verzonden naar Coinbase Prime; 146.507 ETH (ongeveer $324 miljoen) verzonden naar Paxos; 7.800 ETH (ongeveer $17,02 miljoen) verzonden naar FalconX.</p>
<p>Vanaf 13 november 2023, <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a> heeft in totaal 757.626 ETH (ongeveer $1,69 miljard) overgemaakt naar FalconX, Coinbase, OKX en Paxos. Momenteel houdt Celsius nog steeds 62.469 ETH (ongeveer $138 miljoen) aan op adres 0xdb3.</p>
<p>Volgens ai_9684xtpa monitoring heeft de hoog winnende walvis, die eerder voornamelijk bullish was, 7 uur geleden 6.600 ETH geleend van Maker en ze allemaal verkocht tegen een gemiddelde prijs van $2.230, ter waarde van $14,72 miljoen. Later, toen ETH daalde, kocht hij alle tokens terug tegen een gemiddelde prijs van $2.208 en loste de lening af, uiteindelijk een winst van $497.000 behalend.</p>
<p>BlockBeats nieuws: Op 25 januari hebben Ethereum-ontwikkelaars een definitief schema ingesteld voor de upgrade van “Denchun”. Als het soepel verloopt op de testnetwerken van Sepolia en Holesky op 30 januari en 7 februari, zullen ontwikkelaars de datum bepalen waarop “Denchun” wordt ingelogd op het Ethereum-hoofdnetwerk. Het huidige doel is eind februari of begin maart.</p>
<p>Het is weer de maandelijkse optie leveringsdatum. Volgens Deribit gegevens zullen BTC opties met een nominale waarde van $3,74 miljard morgen verlopen en geleverd worden, met een Put Call Ratio van 0,52 en een maximale pijn punt van $41.000. ETH opties met een nominale waarde van $2,05 miljard zullen morgen verlopen en geleverd worden, met een Put Call Ratio van 0,31 en een maximale pijn punt van $2.300.</p>
<p>Daarnaast is ook een openbare opiniepeiling de moeite waard om op te letten. Gisteren, volgens een mediastudie van Europese cryptocurrency-gebruikers in Frankrijk, Spanje, Italië en Zweden, was 73% van de respondenten optimistisch over de toekomst van cryptocurrencies. Deze enquête duikt in de voorkeuren en gedragingen van Europese cryptogemeenschappen. 55% van de deelnemers maakt volledig gebruik van digitale activa, wat aangeeft dat deze financiële instrumenten een belangrijke positie innemen onder de ondervraagde bevolking.</p>
<p>De enquête onthulde ook enkele belangrijke trends: 55% van de deelnemers gebruikt digitale activa bij hun dagelijkse boodschappen, en 10% gebruikt cryptocurrency om wekelijks goederen te kopen. Wat betreft het gebruik, gebruikt 34% van de respondenten het voor langlopende transacties, 26% voor spaargeld, 13% voor dagelijkse transacties en 9% voor dagelijkse aankopen.</p>
<p>De belangrijkste drijfveren voor de adoptie van crypto zijn het hoge rendementspotentieel (20% van de respondenten), decentralisatie en financiële autonomie (18% van de respondenten), en interesse in innovatie en technologie (17% van de respondenten). 82% van de respondenten is ten minste één jaar actief geweest op de cryptomarkt, waarbij 73% tussen 1 en 5 jaar heeft deelgenomen. Wat betreft opslagvoorkeuren gebruikt 65% van de respondenten doorgaans gecentraliseerde exchange wallets, gevolgd door hardware wallets (18%).</p>
<h2 id="h2-Macro20De20groei20van20het20BBP20overtreft20de20verwachtingen20waarbij20er20wordt20ingezet20op20renteverlagingen20met20als20inzet20herhaalde20horizontale20sprongen445191"><a name="Macro: De groei van het BBP overtreft de verwachtingen, waarbij er wordt ingezet op renteverlagingen met als inzet ‘herhaalde horizontale sprongen’." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De groei van het BBP overtreft de verwachtingen, waarbij er wordt ingezet op renteverlagingen met als inzet ‘herhaalde horizontale sprongen’.</h2><p>Op donderdag groeide het bbp van de Verenigde Staten in het vierde kwartaal met 3,3% meer dan verwacht, gedreven door de groei van de persoonlijke uitgaven. Het aantal eerste werkloosheidsaanvragen in de Verenigde Staten voor de week die eindigde op 20 januari bedroeg 214.000, een nieuw hoogtepunt sinds de week die eindigde op 23 december 2023. Na de bekendmaking van de gegevens verhoogden handelaren hun inzet op een renteverlaging door de Fed, wat erop kan wijzen dat de Fed minder haast heeft om de rente te verlagen.</p>
<p>Beïnvloed door deze gegevens steeg de Amerikaanse dollarkoers aanzienlijk tijdens de Amerikaanse handelssessie en bereikte op een gegeven moment een intraday hoogtepunt van 103,68, om uiteindelijk met 0,23% te sluiten op 103,48; Het rendement op de Amerikaanse 10-jaars staatsobligaties naderde kort de 4,2% tijdens de handel, maar keerde vervolgens om en sloot op 4,120%; Het rendement op de Amerikaanse 2-jaars staatsobligaties, die gevoeliger zijn voor het rentebeleid van de Federal Reserve, sloot op 4,299%.</p>
<p>Spot goud maakte een achtbaanrit, daalde onder het niveau van 2010 voor de Amerikaanse markt en bereikte een intraday-dieptepunt van 2009,60. Vervolgens herwon het alle verloren terrein en schommelde heen en weer rond het niveau van 2020, uiteindelijk sloot het 0,35% hoger op $2.020,86 per ounce. Spot zilver steeg opnieuw met meer dan 1% en sloot uiteindelijk 1,07% hoger op $22,91 per ounce.</p>
<p>Als gevolg van de voortdurende verstoring van de mondiale handel veroorzaakt door de gespannen situatie in de Rode Zee, kunnen de internationale ruwe olieprijzen met meer dan 2% stijgen. WTI-ruwe olie steeg aanzienlijk op de dag en sloot uiteindelijk 2,3% hoger op $77,04 per vat; Brent-ruwe olie stabiliseerde rond de $80 en sloot uiteindelijk 2,43% hoger op $82,18 per vat. De Amerikaanse aandelenindex steeg met 0,64%, de S&amp;P 500-index steeg met 0,53% en de Nasdaq steeg met 0,18%.</p>
<p>Nu groeide de Amerikaanse economie sneller dan verwacht in het vierde kwartaal, wat een perfect einde betekent van een jaar dat velen hadden verwacht te eindigen met een economische recessie.</p>
<p>Volgens gegevens van het Bureau of Economic Analysis van de Verenigde Staten bedroeg het initiële geannualiseerde kwartaalpercentage van het reële bbp voor het vierde kwartaal van de Verenigde Staten 3,3%, wat hoger is dan de verwachtingen van 2% en lager dan de vorige 4,9%, waarmee het een nieuw laagterecord bereikte sinds het tweede kwartaal van 2023. Dit heeft geleid tot een groei van 2,5% van de Amerikaanse economie in 2023, een stijging ten opzichte van 1,9% in 2022. Het initiële werkelijke kwartaalpercentage van de persoonlijke consumptie-uitgaven in het vierde kwartaal van de Verenigde Staten bedroeg 2,8%, hoger dan de verwachte 2,5%, wat een nieuw laagterecord is sinds het tweede kwartaal van 2023, met een vorige waarde van 3,1%.</p>
<p>Ondertussen vertoont de arbeidsmarkt tekenen van afkoeling, met het aantal eerste werkloosheidsaanvragen in de Verenigde Staten dat 214.000 bereikte voor de week die eindigde op 20 januari, een nieuw hoogtepunt sinds 23 december 2023, en hoger dan de verwachtingen van 200.000. De vorige waarde werd verhoogd van 187.000 naar 189.000.</p>
<p>Nadat de gegevens bekend waren gemaakt, stegen de kortetermijnrente-futures in de Verenigde Staten omdat handelaren meer inzetten op een renteverlaging door de Fed.</p>
<p>Volgens de ‘Federal Reserve Observation’ van CME is de kans dat de Federal Reserve de rentetarieven in februari handhaaft tussen 5,25% en 5,50% 97,4%, en de kans op een renteverlaging van 25 basispunten is 2,6%. De kans dat de rentetarieven ongewijzigd blijven tot maart is 48,7%, de kans op een cumulatieve renteverlaging van 25 basispunten is 50,0%, en de kans op een cumulatieve renteverlaging van 50 basispunten is 1,3%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 enkele beleggingssuggestie.<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 zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>