TWFya3R0cmVuZCB8IE5GVC12ZXJrb3BlbiBzdGlqZ2VuIG1ldCA4JSBuYSBtYWFuZGVuIHZhbiBkYWxpbmdlbiwgUG9seWdvbiBiZXdlZWd0IHppY2ggZGV6ZSBtYWFuZCBuYWFyIGVlbiBoYXJkIGZvcms=

2023-01-13, 03:04

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""></p>
<p>De afgelopen week lijkt de berenmarkt die de markt gedurende 2022 heeft geteisterd, verbannen te hebben en in plaats daarvan een toestroom van groene kaarsen te hebben geïntroduceerd. Een meerderheid van de activa binnen de top honderd heeft deze week aanzienlijke stijgingen doorgemaakt in vergelijking met voorgaande weken, waardoor ze waarde hebben kunnen herstellen en zich kunnen verzetten tegen de weerstand die de markt heeft geplaagd.</p>
<p>Nu de algemene marktsentiment de markt in een positiever daglicht stelt, heeft dit geleid tot een golf van innovatie en ontwikkeling op het gebied van blockchains, evenals de hernieuwde interesse in voorheen lucratieve blockchain sub-industrieën. Ondanks dit positieve nieuws hebben Amerikaanse regulerende instanties zich gericht op een aantal internationale beurzen vanwege het illegaal en onrechtmatig aanbieden van niet-geregistreerde effecten, waardoor de discussie over de toekomst van regulering binnen de bredere cryptocurrency-markt verder wordt gevoerd.</p>
<h2 id="h2-Het20Laatste20Nieuws649142"><a name="Het Laatste Nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Laatste Nieuws</h2><h3 id="h3-NFTverkopen20stijgen20met20820na20maanden20van20dalingen989728"><a name="NFT-verkopen stijgen met 8% na maanden van dalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NFT-verkopen stijgen met 8% na maanden van dalingen</h3><p>NFT’s waren misschien wel een van de zwaarst getroffen industrieën binnen het blockchain-gebied, aangezien de bearmarkt marktwaarderingen deed kelderen, bedrijven failliet gingen en de interesse in meer ‘experimentele’ gebieden van deze opkomende technologische wereld afnam. Deze daling duurde acht maanden, waarbij verschillende NFT’s die voorheen miljoenen waard waren, nu nog maar een paar cent waard zijn, maar dit veranderde eind december, toen de maandelijkse handelsvolume van NFT’s met 13% steeg tot een totaal van $549,5 miljoen.</p>
<p>Echter heeft analist Thomas Bialek van The Block Research dit toegeschreven aan ‘waarschijnlijk een combinatie van het oogsten van belastingverliezen en de heropleving van populaire verhalen rondom enkele belangrijke PFP-projecten, met name Yuga Labs, gezien hun aankomende ‘Trial of Jimmy The Monkey’-evenement. Als laatstgenoemde de belangrijkste drijfveer is achter deze toestroom van interesse in de NFT-ruimte, zou dit kunnen aangeven dat NFT’s opnieuw hun <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">Status</a> in zowel blockchain als de mainstream door hun vreemde en wonderlijke aard met de wereld te delen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578665001.png" alt=""><br>Een voorbeeld van een NFT (afbeelding met dank aan Shutterstock)</p>
<h3 id="h3-Polygon20beweegt20zich20deze20maand20naar20een20hard20fork693726"><a name="Polygon beweegt zich deze maand naar een hard fork" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Polygon beweegt zich deze maand naar een hard fork</h3><p>Ontwikkelaars bij het <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> PoS blockchain hebben onlangs voorgesteld om een netwerk hard fork te lanceren op 17 januari, met als doel de impact van spikes in transactiekosten en keten reorganisaties op het Polygon netwerk te verminderen. Door dit te doen, streven ontwikkelaars ernaar om het netwerk te verbeteren en upgraden, zodat de beveiliging van blokken op de sidechain netwerken verbeterd kan worden, en om de sporadische en volatiele gas kosten en gebruik op het netwerk te minimaliseren. Daarnaast hopen Polygon ontwikkelaars door het herorganiseren van de keten de Polygon mainnet beter te beveiligen tegen reorganisaties, gezien de geschiedenis van de PoS keten die vatbaar is voor ‘reorgs’, wat leidt tot verwarring met betrekking tot transactie verificatie.</p>
<p>Indien goedgekeurd door de gemeenschap, zal de hard fork later deze maand plaatsvinden als onderdeel van een breder initiatief om de technische mogelijkheden van de Polygon side chain te verbeteren, waaronder zaken als parallelisatie en de Polygon zkEVM.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578723002.png" alt=""><br>Polygon-logo (afbeelding met dank aan Forbes Advisor)</p>
<h3 id="h3-SEC20klaagt20Gemini20en20Genesis20aan20voor20nietgeregistreerde20effectenaanbiedingen848828"><a name="SEC klaagt Gemini en Genesis aan voor niet-geregistreerde effectenaanbiedingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC klaagt Gemini en Genesis aan voor niet-geregistreerde effectenaanbiedingen</h3><p>De Securities and Exchange Commission (SEC) heeft crypto-beurzen Gemini en Genesis aangeklaagd wegens niet-geregistreerde aanbieding en verkoop van effecten aan particuliere beleggers, waarvan sommigen zich in de VS bevonden. De SEC is de afgelopen jaren strenger gaan optreden tegen een reeks blockchainbedrijven en beurzen vanwege regelovertredingen, met name met betrekking tot het aanbieden van niet-geregistreerde effecten - met de Ripple vs SEC-zaak als het meest beruchte voorbeeld.</p>
<p>Dit nieuws komt aan het licht van de lopende publieke ruzie tussen de leiderschaps teams van zowel Gemini als Genesis na de samenwerking om retailbeleggers effecten aan te bieden en te verkopen via een Gemini crypto-uitleenplatform. De twee bedrijven gingen eerder deze maand uit elkaar na een schandaal gerelateerd aan deelnemers van het programma ‘Gemini Earn’, aangeboden door Genesis via hun platform, die niet in staat waren om toegang te krijgen tot hun fondsen vanwege beweringen van ‘onvoldoende liquiditeit’ aan de kant van Genesis, ondanks het feit dat ze meer dan $900 miljoen aan investeringsfondsen in handen hadden. Tyler Winklevoss, mede-oprichter van Gemini, verklaarde dat hij teleurgesteld was in de actie van de SEC tegen Gemini te midden van beweringen dat hij en andere crediteuren werken aan het terugvorderen van fondsen voor deelnemers van Gemini Earn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578746003.png" alt=""><br>Gemini (Afbeelding met dank aan MasterTheCrypto)</p>
<h2 id="h2-Huidige20projecttrends165899"><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, hebben de meeste projecten die afgelopen week de meeste winst hebben behaald, zich gericht op zowel GameFi als de Metaverse. Met beide industrieën die zware crashes hebben ondergaan als gevolg van de bearmarkt, zou deze plotselinge hernieuwde interesse kunnen duiden op de opleving van deze facetten van blockchain. Deze projecten hebben in de afgelopen 24 uur stijgingen tot wel 467,56% doorgemaakt, wat waarschijnlijk te danken is aan het groeiende positieve sentiment binnen de bredere blockchain-industrie.</p>
<h2 id="h2-De20huidige20BTCtrend111645"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p>De vorige week heeft aangewakkerd <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> naar een ongekende stijging, waardoor het vrijkomt van lokale weerstandszones van $16.800 en boven de drempel van $18.000 stijgt. Met een winst van alleen al 11,34% deze week, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Uit de uurgrafieken van ‘s is gebleken dat het consequent vooruitgelopen is op de gerapporteerde CPI-gegevens en blijft testen tegen de opwaartse weerstand van $18.238. Met de gegevens die op 6,5% uitkwamen, wordt verwacht dat de bulls de steunzone van $17.609 zullen moeten verdedigen en het momentum moeten blijven bieden dat nodig is om tussen de zone van $18.238 en $18.382 te blijven handelen, zoals. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Blijft binnen deze drempel kan erop wijzen dat het binnenkort weer boven $19.000 zal handelen, de volgende verwachte belangrijke weerstandszone.</p>
<p>Na deze positieve beweging, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>‘s MVRV (marktwaarde ten opzichte van gerealiseerde waarde) is aanzienlijk gestegen in de afgelopen week. Bij het begin van de week stond BTC’s MVRV op 0,854, het hoogste niveau in enkele weken, waarna het steeg naar een piek van 0,934 op de 12e. Dit duidt erop dat BTC eindelijk weg zou kunnen zijn van de indicatie van de ‘marktbodem’ en meer richting het stabielere gebied beweegt, wat aangeeft dat het actief momenteel naar een realistischere en volledig gerealiseerde waardering beweegt. Toch, met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> nog steeds handelend onder zijn gerealiseerde waarde, dit duidt erop dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> kan een goede investering zijn, omdat het nog ver verwijderd is van een gezonde waarderingszone.<br><img src="https://gimg2.gateimg.com/image/article/1673578824004.png" alt=""><br>Maandelijkse BTC MVRV-gegevens (gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20staat20van20ETHgasvergoedingen377985"><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>Vanaf 12 januari is er een opmerkelijke daling geweest in het totale volume gas dat de afgelopen week is gebruikt in vergelijking met daarvoor, waarbij het laagste cijfer op de 12e is bereikt, met een totaal van 108.298.134.693. Het hoogste cijfer dat deze week is bereikt, was op de 8e, met een totaal van 108.934.894.219, wat een vergelijkbaar totaal gebruik is als aan het einde van 2022. Ondanks deze kleine verandering in het volume gas dat wordt gebruikt, lijkt het huidige volume gas dat wordt gebruikt in lijn te zijn met de huidige maandelijkse trends.</p>
<p>Als gevolg hiervan zijn de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> gasvergoedingen deze week aanzienlijk gedaald ten opzichte van de voorgaande week. De lage gasgrenzen lagen tussen 11-116 gwei, de gemiddelde grenzen lagen tussen 11-116 gwei, en de hoge grenzen lagen tussen 11-167 gwei - wat een aanzienlijk verschil in gasvergoedingen aantoont gedurende de afgelopen week.</p>
<p>In de afgelopen 24 uur waren de top ‘Gas Guzzlers’ volgens Etherscan Seaport 1.1 (met kosten van in totaal $269.171,70 of 191,41 ETH), <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Router 2 (met kosten van in totaal $312.318,15 of 222,09 ETH) en Uniswap V2: Router 2 (met kosten van in totaal $196.914,53 of 140,03 ETH) - wat een aanzienlijke stijging laat zien ten opzichte van de vorige week.</p>
<p>De geschatte kosten van transacties over platformen zoals OpenSea: Verkoop, Uniswap V3: Omwisseling, en USDT: Overdracht, worden geschat tussen $1,29 en $4,93, volgens Etherscan.</p>
<h2 id="h2-De20Huidige20Macro20Situatie792049"><a name="De Huidige Macro Situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Huidige Macro Situatie</h2><h3 id="h3-BTC20Benvloed20door20recente20CPIgegevens381652"><a name="BTC Beïnvloed door recente CPI-gegevens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC Beïnvloed door recente CPI-gegevens</h3><p>Met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> na een indrukwekkende bullish streak in de afgelopen week, is het nu tijd om te zien of de onlangs vermelde CPI (consumentenprijsindex) van 6,5% de waardering verder zal beïnvloeden. Als het cijfer 6,3% of lager is, wordt doorgaans een bullmarkt voorspeld, omdat dit de projecties van de Amerikaanse centrale bank van het laatste FOMC ongeloofwaardig maakt, maar tussen 6,3% en 6,5% is de markt meestal terughoudend, maar kan deze blijven stijgen, terwijl tussen 6,5% en 7,1% een uitverkoop wordt verwacht. Aangezien JP Morgan verwacht dat deze CPI-gegevens een opwaartse beweging van 1,5-2% in de S&amp;P 500 zouden kunnen veroorzaken, zou dit positief kunnen correleren met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> waardering en verdere ondersteuning van zijn momentum. Dit wordt reikhalzend uitgekeken als <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> blijft doorgaan naar de $19.000 drempel en bevrijdt zich van zijn 90-daagse SMA.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week630448"><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>Met de huidige markttoestand die een eensgezind positief sentiment vertoont wat betreft waardering, investeerdersbelangstelling en innovatie, kan worden vastgesteld dat de komende week ook door deze factoren zal worden beïnvloed, waardoor deze ogenschijnlijk bullish momentum wordt aangemoedigd. Dit zou uiteindelijk kunnen leiden tot het blijven toenemen van de waarde van verschillende activa binnen de top 100, terwijl verschillende industrieën binnen blockchain zich opnieuw beginnen te vestigen nu de interesse in hun technologie weer groeit.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io Onderzoeker: <strong>Matthew Webster-wichelroedelopen</strong><br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle andere glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>