TWFya3R0cmVuZCB8IEFEQSBtaWt0IG9wICQxIHRlcndpamwgRGplZCBTdGFibGVjb2luIHdvcmR0IGdlbm90ZWVyZDsgQ29pbmJhc2UgYmVib2V0IG1ldCAkMyw2IG1pbGpvZW4gZG9vciBkZSBOZWRlcmxhbmRzZSBDZW50cmFsZSBCYW5r

2023-01-27, 08:40

<p><img src="https://gimg2.gateimg.com/image/article/1674200553%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""></p>
<p>De afgelopen week is een gemengde zak geweest voor de cryptocurrency markt. Na te zijn begonnen op een relatief bearish toon en in overeenstemming met de voortdurende verslechtering van de aandelenmarkt, is de markt snel vrijgekomen van deze beperkingen en in een meer bullish territorium terechtgekomen. Na de bullish golf van de vorige week te hebben hersteld, lijkt de cryptocurrency markt klaar te zijn voor verdere groei. Naast deze bullishness zijn de <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> bulls begonnen met het anticiperen op de potentie van een doorbraak van de $1 drempel, aangezien de release van de Djed stablecoin, met dank aan COTI, dichterbij komt.</p>
<p>Daarnaast anticiperen BTC-stieren dat het actief de komende weken de drempel van $28k kan doorbreken als de gouden kruisvorming wordt gerealiseerd en er een bullish momentum ontstaat. Aan institutionele zijde staat Coinbase echter op het punt een boete van meer dan $3,3 miljoen te krijgen van de Nederlandse Centrale Bank wegens beschuldigingen dat de beurs niet heeft voldaan aan de lokale wetgeving.</p>
<h2 id="h2-Het20laatste20nieuws694907"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-Bitcoin2020Eyes2028K20Leaving20Bears20In20Disbelief824170"><a name="Bitcoin  Eyes $28K Leaving Bears In Disbelief" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Eyes $28K Leaving Bears In Disbelief</h3><p>In de afgelopen paar weken, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> heeft kunnen profiteren van een bullish golf die een aanzienlijk deel van de waarde heeft doen herleven en het vrij heeft gemaakt van de menigte van het $13-19k gebied. Nu boven de $20k drempel, richten de stieren zich nu op $28.000 als volgend prijsplafond, in de verwachting dat als het huidige momentum kan worden gehandhaafd, het haalbaar is dat BTC deze hoogtepunten kan bereiken. Na al te zijn ontsnapt aan een vier maanden durende berencyclus, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blijft consequent naar nieuwe viermaandelijkse hoogtepunten duwen en wordt nu verhandeld tegen een gemiddelde van $23.000.</p>
<p>Een analist onder het pseudoniem, Thescalpingpro, heeft verklaard dat de zone van $23.500 tot $24.500 een sleutelgebied blijft om in de gaten te houden, en heeft verklaard dat hij gelooft dat het overschrijden van dit gebied zal duwen <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> tot $28.100. Met dit als een zwaar weerstandsgebied zou deze belangrijke zone kunnen fungeren als een prijsplafond, op voorwaarde dat BTC niet genoeg momentum kan krijgen om voorbij deze zone te duwen. Op dit moment zijn de beren voornamelijk aan het shorten. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>, maar het is mogelijk dat de overkoepelende bullish sentimenten deze handelsstrategie veranderen en futures en langetermijnhandelsstrategieën opnieuw introduceren.</p>
<h3 id="h3-ADA20richt20zich20op20120terwijl20Djed20Stablecoin20wordt20genoteerd878659"><a name="ADA richt zich op $1 terwijl Djed Stablecoin wordt genoteerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ADA richt zich op $1 terwijl Djed Stablecoin wordt genoteerd</h3><p>Deze bullish sentiment is uitgebreid naar Cardano, waar stieren en analisten allebei anticiperen op het weer naderen van $1 voorafgaand aan de implementatie van hun Djed stablecoin. De Djed stablecoin, die volgende week zal worden uitgebracht, is bedoeld om uitbreiding en nieuwe toepassingen in het Cardano-ecosysteem te bevorderen. COTI, een platform geoptimaliseerd voor het creëren van prijsstabiele munten en de binnenkort uit te geven Djed, heeft de planning van de release voor volgende week bevestigd en heeft gewezen op de aanzienlijke technologische ontwikkelingen in de infrastructuur.</p>
<p>Het COTI-team heeft ook opgemerkt dat een van de belangrijkste technologische vooruitgangen die wordt gebruikt voor de Djed stablecoin een ‘chain indexing proces’ omvat, dat volgens hen 14 dagen in beslag zal nemen voordat de Djed wordt gelanceerd. Chain index syncing duidt op een proces dat erop gericht is ervoor te zorgen dat alle knooppunten in een netwerk worden bijgewerkt over kwesties zoals transacties en blokken om de gezondheid en veiligheid van het netwerk te waarborgen.</p>
<h3 id="h3-Coinbase20krijgt20boete20van203620miljoen20dollar20van20De20Nederlandsche20Bank895502"><a name="Coinbase krijgt boete van 3,6 miljoen dollar van De Nederlandsche Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coinbase krijgt boete van 3,6 miljoen dollar van De Nederlandsche Bank</h3><p>Coinbase is officieel beboet door de Nederlandse Centrale Bank. Dit komt aan het licht omdat de cryptocurrency exchange gigant niet heeft voldaan aan de lokale wetgeving tijdens november 2020 en augustus 2022. De Nederlandse Centrale Bank heeft naar verluidt in overweging genomen dat het platform een van de belangrijkste aanbieders in de regio is en een ‘aanzienlijk aantal klanten op lokale bodem’ heeft. Dit nieuws verergert verder de recente negatieve berichtgeving rond de beurs, waarbij momenteel een rechtszaak loopt over exploits en het verwijderen van gebruikersfondsen in Amerika.</p>
<p>Bovendien heeft Coinbase bevestigd dat ze hun diensten niet langer zullen aanbieden aan de Japanse markt, waarbij ze beweren dat ongunstige economische omstandigheden de voornaamste oorzaak zijn. Als gevolg daarvan zijn stortingen vorige week stopgezet en hebben Japanse gebruikers tot medio februari de tijd om hun bezittingen op te nemen.</p>
<h2 id="h2-Huidige20projecttrends530283"><a name="Huidige projecttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige projecttrends</h2><p>Op basis van gegevens verstrekt door CoinMarketCap, heeft een meerderheid van de projecten met de grootste winst in de afgelopen week zich gericht op het oplossen van het blockchain trilemma, met name het schaalbaarheidsaspect. Met een ongekende groei van 3.681% in de afgelopen 24 uur heeft de Pascal-token de meest substantiële groei laten zien in vergelijking met enig ander actief dat momenteel op de markt beschikbaar is. Het is in deze afgelopen week met bijna 7.000% gegroeid.</p>
<h2 id="h2-De20huidige20BTCtrend69335"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p>Na een stijging van meer dan 11% in de afgelopen zeven dagen, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> lijkt momenteel klaar voor een bullish uitbraak, dit lijkt al in de kaarten te zitten. Vanwege de mogelijke vorming van een bullish golden cross formatie, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Volgens analist Thescalpingpro kan het zijn dat de prestaties van may continue to exceed its recent performance and accelerate through the $23,500 resistance zone and potentially break into the key zone of $23,500 and $24,500, wat het naar bullish hoogtes van $28,100 zou kunnen stuwen - een van de hoogste niveaus die de asset heeft gezien in meer dan zes maanden. Dit zou kunnen zorgen voor een stijging van de koers. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> om in een stierenmarkt te komen, is het echter cruciaal dat BTC in staat is om het huidige bullish momentum te behouden om dit te bereiken.</p>
<p>Echter, op een meer bullish noot, hebben sommige analisten ook opgemerkt dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> kan mogelijk geconfronteerd worden met de eerste death cross op de grafiek van één week, wat resulteert in een bearish sentiment. De huidige marktomstandigheden in combinatie met deze verontrustende potentiële formatie vormen vergelijkbare omstandigheden met die van de bear fase in 2022. Op een meer positieve noot merkt Thescalpingpro ook op dat de huidige prijsbeweging van BTC overeenkomt met de handelsroute van 2015, waar BTC met 214% steeg voordat een death cross gerealiseerd werd. Dit suggereert uiteindelijk dat er een bullish belofte is voor BTC, maar het is kritisch om voorzichtig te zijn.</p>
<p>Na deze gemengde gevoelens, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> De MVRV (marktwaarde ten opzichte van gerealiseerde waarde) van BTC is de afgelopen week aanzienlijk toegenomen en blijft consequent boven de drempel van 1. Bij aanvang van de week stond de MVRV van BTC op 1,079, een van de hoogste waarden in meerdere weken. Op de 26e steeg dit zelfs naar een hoogtepunt van 1,164. Dit duidt erop dat BTC eindelijk weg is van de ‘marktonderkant’ en zich richting een meer stabiel gebied beweegt, waarbij de waarde meer volledig gerealiseerd wordt.<br><img src="https://gimg2.gateimg.com/image/article/1674808616111.png" alt=""></p>
<p>Wekelijkse BTC MVRV-gegevens (gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20staat20van20ETHgasvergoedingen296280"><a name="De staat van ETH-gasvergoedingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De staat van ETH-gasvergoedingen</h2><p>Op 26 januari is er een gematigde daling geweest in het totale volume gas dat afgelopen week is gebruikt in vergelijking met daarvoor, met het laagste cijfer bereikt op de 26e, in totaal 108.499.288.876. Het hoogste cijfer dat deze week is bereikt was op de 22e, totaal 108.891.672.082, wat een vergelijkbaar totaal gebruik laat zien als dat gezien gedurende de opening van 2023. Ondanks deze enorme verandering in het volume gas dat is gebruikt, lijkt het huidige volume gas in lijn te zijn met de huidige maandelijkse trends.</p>
<p>Als gevolg hiervan zijn de Ethereum-gaslimieten deze week aanzienlijk gestegen ten opzichte van de voorgaande week. De lage gaslimieten lagen tussen 10-480 gwei, de gemiddelde limieten lagen tussen 11-573 gwei en de hoge limieten lagen tussen 11-629 gwei - wat een aanzienlijk verschil in gasvergoedingen laat zien gedurende de afgelopen week.</p>
<p>In de afgelopen 24 uur waren volgens Etherscan de top ‘Gas Guzzlers’ Seaport 1.1 (met totale kosten van $311.779,68 of 222,84 ETH), Uniswap: Universal Router (met totale kosten van $311.331,14 of 164,52 ETH) en <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V2: Router 2 (met totale kosten van $204.941,96 of 140,03 ETH) - wat dus een aanzienlijke stijging is ten opzichte van de vorige week.</p>
<p>De geschatte kosten van transacties via platforms zoals OpenSea: Verkoop, Uniswap V3: Ruilhandel en USDT: Overdracht, worden geschat op tussen $1,46 en $5,58, volgens Etherscan.</p>
<h2 id="h2-De20huidige20macrosituatie927951"><a name="De huidige macro-situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige macro-situatie</h2><p>De laagste economische groeicijfers in decennia zijn voorspeld</p>
<p>In de afgelopen week hebben de meeste westerse aandelenmarkten een opmerkelijke klap gekregen, nadat ze verder zijn gedaald in het licht van gegevens die suggereren dat de groei van de wereldwijde output naar verwachting zal vertragen van een geschatte 3% gezien in 2022, tot 1,9% - een van de laagste groeicijfers in de afgelopen decennia. Dit nieuws werd vandaag gebracht door de United Nations World Economic Situation and Prospects (WESP 2023). Dit sombere rapport heeft een onzekere vooruitzichten geschetst voor het wereldwijde economische toneel in het komende jaar, met name gezien het feit dat de gegevens hebben aangetoond dat er een bedreiging is tegen de verwezenlijking van de 17 Sustainable Development Goals (SDG’s).</p>
<p>Secretaris-generaal van de Verenigde Naties, Antonio Guterres, erkende dit: ‘Dit is niet het moment voor kortetermijndenken of impulsieve financiële bezuinigingen die ongelijkheid verergeren, het lijden vergroten en de SDG’s verder buiten bereik kunnen brengen. Deze ongekende tijden vragen om ongekende actie.’ Iets wat enigszins hoopgevend is, is het feit dat het rapport heeft aangegeven dat de internationale groeisnelheid in 2024 kan stijgen naar 2,7%, naarmate de impact van de recente mondiale crises begint af te nemen. Deze voorspelling is echter sterk afhankelijk van het tempo en de coördinatie van verdere monetaire verkrapping, de gevolgen van de oorlog in Oekraïne en de mogelijkheid van verdere verstoring van de toeleveringsketen.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week387099"><a name="Wat zou er kunnen komen in de komende week?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zou er kunnen komen in de komende week?</h2><p>Gezien de algehele bullishness op de markt en het positieve nieuws over adoptie en regulering, is het zeer waarschijnlijk dat de komende week dit momentum verder zal uitbreiden en het mogelijk uit de dreiging van een bull trap zal halen. Op deze manier zullen verschillende activa binnen de top honderd blijven groeien en waardering genereren, waardoor cryptocurrencies verder uit de bearmarkt worden gehaald.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Matthew Webster-Dowsing</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle gevallen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>