RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gT24tY2hhaW4gVHJhZGluZyBiZXJlaWt0ZSBlZW4gbmlldXcgaG9vZ3RlcHVudDsgRmFyY2FzdGVyIERhaWx5IEFjdGl2aXR5IGJlcmVpa3RlIGVlbiBuaWV1dyBob29ndGVwdW50OyBNZWVyIGRhbiAkMjAwIG1pbGpvZW4gQVBULXRva2VucyB3b3JkZW4gZGV6ZSB3ZWVrIHZyaWpnZWdldmV

2024-02-05, 04:24

<p><img src="https://gimg2.gateimg.com/image/article/17071068761_2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht202020Bitcoin2020onchain20transacties20bereiken20nieuwe20hoogtepunten20dagelijkse20activiteit20van20Farcaster20bereikt20nieuwe20hoogtepunten936348"><a name="Crypto Dagelijks Overzicht:   Bitcoin  on-chain transacties bereiken nieuwe hoogtepunten, dagelijkse activiteit van Farcaster bereikt nieuwe hoogtepunten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> on-chain transacties bereiken nieuwe hoogtepunten, dagelijkse activiteit van Farcaster bereikt nieuwe hoogtepunten</h2><p>Op 5 februari werd het laatste nieuws bekendgemaakt dat het Hooggerechtshof van Verkiezingen in El Salvador de voorlopige stemmen telling voor de verkiezing heeft aangekondigd. De huidige president Nayib Bukele is succesvol herkozen als president en staat op het punt om aan zijn nieuwe ambtstermijn van vijf jaar te beginnen. Nayib Bukele zal op 1 juni van dit jaar zijn ambt aanvaarden en daarmee de eerste president van El Salvador zijn die tijdens de democratische periode herkozen is.</p>
<p>Er wordt gemeld dat Nayib Bukele sinds 2019 president is. In 2021 werd El Salvador het eerste land dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als wettig betaalmiddel.</p>
<p>Onlangs ontdekte CoinShares dat 75% van de respondenten gelooft in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft de meest aantrekkelijke groeivooruitzichten, volgens de laatste enquête van digitale activafondsbeheerders. Het aandeel digitale activa in de beleggingsportefeuille is gestegen van 0,4% van de gemiddelde portefeuille van de respondent tot 1,3%, wat wijst op een toenemende allocatie van digitale activa, en dit aandeel is het hoogste sinds het eerste kwartaal van 2023.</p>
<p>Hoewel regelgevingskwesties nog steeds bovenaan de risicolijst staan, neemt hun belang af, waarbij de combinatie van overheidsverboden en regulering afneemt van 63% zes maanden geleden tot 50%.</p>
<p>Volgens The Block werd in januari 2024 voor een totaal van $1,21 biljoen aan Bitcoin overgemaakt op de keten. Dit is het hoogste maandelijkse handelsvolume sinds september 2022 (toen Bitcoin geprijsd was op ongeveer $20.000). De gegevens tonen ook aan dat behalve december het Bitcoin transactievolume in alle andere maanden van 2023 niet hoger was dan $1 biljoen.</p>
<p>Op 4 februari, volgens gegevens van het bedrijf voor on-chain analyse Glassnode, daalde het aantal actieve netwerkadressen na goedkeuring van Bitcoin-spot ETF’s tot een cyclisch dieptepunt van 219.000 per dag (licht herstellend tot 221.000 deze week).</p>
<p>Dit betekent dat hoewel de prijs van Bitcoin is gestegen, de groei van Bitcoin-gebruikers niet dezelfde opwaartse trend heeft laten zien. Analyse suggereert dat dit voornamelijk te wijten is aan een toename van activiteiten met betrekking tot ordonnanties en inies, waarbij veel deelnemers Bitcoin-adressen hergebruiken, waardoor het aantal actieve adressen wordt verminderd.</p>
<p>Bovendien blijkt uit de meest recente gegevens van Dune dat de cumulatieve kostinkomsten van het gieten van Ordinals-inies in het Bitcoin NFT-protocol 6.076,84 BTC’s hebben bereikt, wat overeenkomt met ongeveer $260 miljoen. Momenteel heeft het totale aantal gegoten inies 59.575.506 overschreden.</p>
<p>In termen van marktfluctuaties plaatste Sun Yuchen op 4 februari op het X-platform dat hij 20 miljoen HT ter waarde van $ 60 miljoen zou vernietigen, die werden verkregen via gebruikersuitwisseling. Naar verluidt zal na voltooiing van de vernietigingsoperatie de totale circulatie van HT worden teruggebracht tot 134 miljoen. Volgens de laatste marktgegevens van Gate.io bedroeg de 24-uurs daling van HT -0,4%, met een notering van $ 2,96.</p>
<p>Volgens gegevens van het on-chain analysebedrijf Glassnode heeft de markt ondanks de recente sterke prestaties van Bitcoin spot ETF’s een tegenovergesteld fenomeen van intuïtie ervaren, waarbij het aantal actieve entiteiten is gedaald tot een cyclisch dieptepunt van 219.000 per dag. Dit betekent dat hoewel de Bitcoin-prijzen zijn gestegen, de groei van Bitcoin-gebruikers hiermee geen gelijke tred heeft gehouden.</p>
<p>Analyse suggereert dat dit voornamelijk te wijten is aan een toename van activiteiten met betrekking tot rangtelwoorden en inies, waarbij veel deelnemers herhaaldelijk gebruik maken van Bitcoin-adressen, waardoor het aantal ‘actieve entiteiten’ (zonder dubbel tellen) wordt verminderd.</p>
<p>Bovendien heeft de dagelijkse actieve gebruiker (DAU) activiteit van het populaire gedecentraliseerde sociale protocol Farcaster onlangs een historisch hoogtepunt bereikt. Het aantal unieke reacties is 24.733, het aantal unieke uitzendingen is 19.081 en de gemiddelde dagelijkse trackwaarde is 10.697.</p>
<p>Op 5 februari toonden de gegevens van Token Unlocks aan dat deze week tokens zoals APT, GAL en HFT een eenmalige grote ontgrendeling zullen ervaren, met een totale waarde van meer dan $235 miljoen. Onder hen:</p>
<p>GAL (Galxe) ontgrendelde op 5 februari om 0:00 uur (UTC) 2,03 miljoen GAL-tokens ter waarde van ongeveer $3,83 miljoen, goed voor 2,26% van de circulerende voorraad;</p>
<p>HFT (Hashflow) zal om 8:00 uur op 7 februari 13,62 miljoen tokens ter waarde van ongeveer $4,25 miljoen vrijgeven, wat overeenkomt met 4,02% van de omloopvoorraad;</p>
<p>APT ( <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>) zal op 11 februari om 20:00 uur 24,84 miljoen APT-tokens ontgrendelen ter waarde van ongeveer $ 228 miljoen, wat overeenkomt met 7,34% van de circulerende voorraad.</p>
<h2 id="h2-Macro20Verwachtingen20voor20renteverlagingen20in20maart20blijven20afnemen20focus20op20Powells20toespraak20op20maandag20van20deze20week575991"><a name="Macro: Verwachtingen voor renteverlagingen in maart blijven afnemen, focus op Powells toespraak op maandag van deze week" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Verwachtingen voor renteverlagingen in maart blijven afnemen, focus op Powells toespraak op maandag van deze week</h2><p>De afgelopen week is een tumultueus seizoen geweest voor de wereldmarkt.</p>
<p>De focus van de markt is verschoven naar de Federal Reserve, en Federal Reserve-voorzitter Powell heeft iets gezegd dat de markt weinig verwachtte, namelijk dat de renteverlaging in maart niet de “basissituatie” is.</p>
<p>Ondanks een aanzienlijke daling van de inflatiecijfers, minimaliseerde Powell de speculatie dat renteverlagingen aanstaande waren. Hij gelooft dat de Federal Reserve nog steeds niet volledig gelooft dat ze de oorlog hebben gewonnen. Hij wees erop dat stabiele economische groei, flexibele consumentenbestedingen en een krappe arbeidsmarkt de inflatiecijfers mogelijk boven de 2% houden gedurende een bepaalde periode.</p>
<p>Zijn boodschap kan zijn dat de rentetarieven uiteindelijk zullen dalen, maar niet zo snel als de markt hoopt. Daarom hebben handelaren hun weddenschappen op de renteverlaging in maart verlaagd van 60% naar ongeveer 35%.</p>
<p>De sterke aankondiging op vrijdag trof de verwachtingen voor de renteverlaging in maart nog harder, waarbij de swapmarkt een afname liet zien van de weddenschappen op de renteverlaging van de Federal Reserve in maart en de renteverlaging van de Fed in mei niet langer volledig inprijsde.</p>
<p>Echter heeft de markt haar visie op het totale aantal renteverlagingen dit jaar niet gewijzigd en is van mening dat de Federal Reserve alleen de timing van renteverlagingen heeft uitgesteld, met naar verwachting nog bijna zes renteverlagingen dit jaar.</p>
<p>Vooruitkijkend zal het belangrijkste evenement van deze week de ISM non manufacturing-enquête zijn, die gepland staat voor maandag. Dit is een van de belangrijkste leidende economische indicatoren voor de Amerikaanse economie, waarbij de voorspellingen een significante groei in januari laten zien. Als dat het g is, kan de markt doorgaan met het inzetten op een renteverlaging door de Fed, wat de Amerikaanse dollar helpt om wat momentum terug te krijgen.</p>
<p>Bovendien zei Gullsby van de Federal Reserve afgelopen vrijdag dat er nog ‘weken en maanden’ aan Amerikaanse economische gegevens zijn om te bepalen wanneer de rentetarieven moeten worden verlaagd, en de Federal Reserve zal de inflatie terugbrengen naar haar doel van 2%, maar zal niet streven naar het herstel van prijzen naar niveaus van vóór de inflatie.</p>
<p>Gulsby gelooft dat als de Federal Reserve wil dat de prijzen terugkeren naar het niveau van een paar jaar geleden, het echt de economische groei moet verminderen om dit te bereiken, dus “renteverlagingen worden niet overwogen.” Gulsby gelooft dat alleen vooruitgang, zoals op het gebied van inflatie en werkgelegenheid, hen gerust kan stellen bij het bereiken van hun doelen.</p>
<p>Deze week zullen tal van functionarissen van de Federal Reserve intensief worden ingezet, waarbij wordt voorspeld dat ze de marktverwachtingen voor de eerste renteverlaging van de Fed in maart zullen blijven ondermijnen. Bovendien kan niet worden uitgesloten dat ze de marktinzetten voor de omvang van de renteverlaging van de Fed kunnen onderdrukken.</p>
<p>Powell zal maandagochtend om 8 uur Beijing tijd het gedeelte ‘60 Minutes’ van CBS verlichten. Gezien het feit dat CBS al heeft onthuld dat Powell het onderwerp van renteverlagingen zal bespreken, kan het opnieuw onderdrukken van de marktverwachtingen van renteverlagingen door de Federal Reserve mogelijk een nieuwe correctie in de marktprijzen veroorzaken.</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 visie 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 zal er juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>