RGFnZWxpamtzIG5pZXV3cyB8IDkgU3BvdCBCaXRjb2luIEVURidzIG92ZXJ0cm9mZmVuIE1pY3JvU3RyYXRlZ3kgSG9sZGluZ3M7IEVSQy00MDQgU2VjdG9yIGdlZGFhbGQ7IEV0aGVyZXVtIEwyIFRWTCBzdGVlZyBtZXQgNyw3NyUgb3AgNyBmZWJydWFyaQ==

2024-02-12, 06:32

<p><img src="https://gimg2.gateimg.com/image/article/17077190831_6-06.png" alt=""></p>
<h2 id="h2-Cryptocurrency20Dagelijks20Overzicht20Het20ERC40420spoor20was20over20het20algemeen20naar20beneden20APE20en20andere20tokens20zullen20deze20week20worden20ontgrendeld338865"><a name="Cryptocurrency Dagelijks Overzicht: Het ERC-404 spoor was over het algemeen naar beneden, APE en andere tokens zullen deze week worden ontgrendeld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptocurrency Dagelijks Overzicht: Het ERC-404 spoor was over het algemeen naar beneden, APE en andere tokens zullen deze week worden ontgrendeld</h2><p>Op 11 februari, volgens HODL15 Capital, negen spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hadden binnen 21 dagen na hun lancering 216.309 Bitcoins (ter waarde van $10,3 miljard) gekocht, wat de huidige holdings van MicroStrategy van 190.000 Bitcoins overtreft.</p>
<p>Eerder gemeld, verklaarde MicroStrategy (MSTR.O) dat het bedrijf op 5 februari 2024 190.000 Bitcoins in bezit had met een totale kostprijs van $5.93 miljard en een kostprijs van $31.224 per Bitcoin.</p>
<p>Op 12 februari, volgens de marktgegevens van Gate.io, heeft <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> de $48.000 overschreden en staat momenteel op $48.166, met een stijging van 1,02% in de afgelopen 24 uur; <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft de $2.500 overschreden en wordt nu genoteerd op $2.503, een daling van 0,13% binnen 24 uur.</p>
<p>Volgens CoinGecko-gegevens is er een algemene scherpe daling geweest in het ERC-404-tokentrack, waarbij PANDORA een daling van 38,7% in 24 uur heeft ervaren en momenteel wordt genoteerd op $15.095; DEFROGS heeft een daling van 36,5% in 24 uur meegemaakt en wordt momenteel genoteerd op $1246; RUG heeft een daling van 43,5% in 24 uur meegemaakt en wordt nu genoteerd op $265.</p>
<p>Op 11 februari bedroeg het huidige totale lockup volume (TVL) van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer2 volgens L2BEAT-gegevens $23,1 miljard, met een stijging van 7,77% in 7 dagen. Onder hen zijn de top vijf opgesloten hoeveelheden:</p>
<p>Arbitrum One ($11.46 miljard, 7-daagse stijging van 7.13%);</p>
<p>OP Mainnet ($5.8 miljard, 7-daagse stijging van 10.99%);</p>
<p>Manta Pacific ($1.62 miljard, 7-daagse stijging van 2.45%);</p>
<p>Basis ($800 miljoen, stijging van 7,06% in 7 dagen);</p>
<p>Metis ($703 miljoen, met 11,98% gestegen op de 7e).</p>
<p>Wat betreft marktschommelingen, heeft Bitcoin Whale volgens Santiment-gegevens de afgelopen drie weken 140.000 BTC ter waarde van $6,16 miljard gekocht.</p>
<p>Bovendien heeft Ethereum mede-oprichter Jeffrey Wilcke volgens Spot On Chain-monitoring 4.300 ETH’s ($10,7 miljoen) gestort bij Kraken voor $2.482 ongeveer 14 uur geleden.</p>
<p>Het is het vermelden waard dat de laatste keer dat hij 22.000 ETH stortte bij Kraken tegen een prijs van $1.870 ($41,1 miljoen) was in juni 2023, vlak voor de marktcrash.</p>
<p>Op dit moment bezit Jeffrey Wilcke nog steeds 146.000 ETHs ($362 miljoen).</p>
<p>Op 11 februari, volgens Nansen 2-gegevens, is de lijst met 24-uursfondsinvoer voor het Ethereum-netwerk van Smart Money als volgt:</p>
<p>ALT: Ongeveer $870.000, momenteel genoteerd op $0,35, een daling van 5,4% binnen 24 uur;</p>
<p>OLAS: Ongeveer $400.000, momenteel genoteerd op $4.95, met een stijging van 24,5% in 24 uur;</p>
<p>LDO: Ongeveer $390.000, momenteel genoteerd op $2,97, met een daling van 1,39% in de afgelopen 24 uur.</p>
<p>Op 12 februari toonden de gegevens van Token Unlocks aan dat deze week tokens zoals CYBER, SAND en APE een eenmalige grote ontgrendeling zullen ervaren, met een totale waarde van meer dan $130 miljoen. Onder hen:</p>
<p>CYBER (CyberConnect) zal om 8:00 (UTC) op 14 februari 2,36 miljoen CYBER-tokens ter waarde van ongeveer $17,99 miljoen vrijgeven, wat overeenkomt met 15,93% van de circulerende voorraad;</p>
<p>SAND ( <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">De Sandbox</a>) zal 205 miljoen tokens ontgrendelen ter waarde van ongeveer $97,32 miljoen om 16:00 uur (UTC) op 14 februari, wat overeenkomt met 9,19% van de circulerende voorraad;</p>
<p>APE ( <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a>) zal om 20:00 uur (UTC) op 16 februari 15,6 miljoen APE-tokens ter waarde van ongeveer $22,47 miljoen ontgrendelen, wat overeenkomt met 2,61% van de circulerende voorraad.</p>
<h2 id="h2-Macro20Bitcoin20breekt20door204800020maar20blijft20bullish20in20de20toekomst23826"><a name="Macro: Bitcoin breekt door $48.000, maar blijft bullish in de toekomst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bitcoin breekt door $48.000, maar blijft bullish in de toekomst</h2><p>Gefeliciteerd met het Chinese Nieuwjaar! Het begin van het Jaar van de Draak werd vergezeld door de sterke prestaties van Bitcoin. BTC brak in de vroege ochtend de $48.200 grens, waarbij het zijn sterke sorteermode op het vier-uur niveau grafiek toonde.</p>
<p>Vanuit de algemene trend heeft de markt een reeks consolidatie- en opwaartse cycli doorlopen en bevindt zich momenteel in een periode van sterke consolidatie, wat aangeeft dat het ondersteuningsniveau geleidelijk omhoog beweegt. De markt verwacht dat Bitcoin zijn opwaartse trend zal voortzetten, en zodra de bodem stabiliseert en het handelsvolume toeneemt, wordt voorspeld dat de Bitcoin-prijzen een langzame opwaartse fase zullen ingaan.</p>
<p>Tijdens dit proces voegde de countdown naar de halvering van Bitcoin ook anticipatie toe aan de markt. Terugkijkend op de trend sinds Bitcoin doorbrak de $30.000 mark in oktober 2023, had de markt sterke verwachtingen voor Bitcoin spot ETFs.</p>
<p>Op het moment dat de ETF werd goedgekeurd, werd de prijs van Bitcoin opgedreven naar een hoogtepunt van $49.000. Echter, doordat instellingen en grote investeerders profiteerden van het grayscale-smashing gedrag, daalde de prijs kortstondig naar $38.554.</p>
<p>Desalniettemin blijven de negen belangrijkste Bitcoin spot ETF’s hun posities vergroten, wat aangeeft dat de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> Het overboeken van fondsen tussen institutionele beleggers is niet gestopt.</p>
<p>De impact van marktstemmen op de prijs van Bitcoin kan niet worden genegeerd. Sommige stemmen hebben voorspeld dat Bitcoin in februari zal dalen tot $26.500 of zelfs lager, wat in lijn is met het gedrag van grote investeerders die contracten verkopen en voor aanzienlijke marktvolatiliteit zorgen. Gedurende deze periode hebben veel investeerders verliezen geleden als gevolg van paniekverkopen.</p>
<p>De recente doorbraakstijging van Bitcoin kan echter een nieuwe ronde van contractdefaults hebben veroorzaakt.</p>
<p>In deze altijd veranderende cryptomarkt garandeert eenvoudige inspanning niet altijd succes. Belangrijker nog is het maken van de juiste keuzes en een diepgaand begrip van de markt hebben.</p>
<p>Naarmate we het Jaar van de Loong binnengaan, moeten investeerders hun vorige operationele strategieën veranderen als ze kansen blijven zoeken op de cryptomarkt. Het patroon van de cryptomarkt ondergaat veranderingen, vooral na het tijdperk van Bitcoin spot ETF’s.</p>
<p>Ethereum zag ‘s avonds ook een bullish toename van het volume, waarbij de prijzen zich boven de $ 2.500 stabiliseerden. Vanaf de vieruurgrafiek vertoont Ethereum een fluctuerende opwaartse trend en herstelt het zich naar een nieuw hoogtepunt na het vinden van ondersteuning rond $ 2.320. De vieruurs grafiek laat zien dat Ethereum het momentum heeft om door hoge niveaus te breken. Terwijl het dieptepunt geleidelijk stijgt, wacht de markt op kracht om door nieuwe hoogtepunten te breken.</p>
<p>Of het nu Bitcoin of Ethereum is, hoewel beide gedeeltelijke terugtrekkingen zullen ervaren, is de algehele trend nog steeds bullish. Beleggers moeten letten op het ondersteuningsniveau en direct deelnemen aan langdurige handel nadat het dieptepunt is bereikt.</p>
<p>Juiste strategieën en beslissingen zijn cruciaal in deze markt vol variabelen en kansen.</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 opvattingen van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>