TWFya3R0cmVuZO+9nEJUQyB2b2VndCBiaWpuYSAkMSBtaWxqb2VuIG5pZXQtbnVsIGFkcmVzc2VuIHRvZSBpbiBtaW5kZXIgZGFuIGVlbiBtYWFuZDsgUGxheWJveSB2ZXJsaWVzdCAkNCw5IG1pbGpvZW4gYWFuIEVUSCBuYSBhY2NlcHRhdGllIHZhbiBORlQtYmV0YWxpbmdlbg==

2023-03-17, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/167843662920230310-162305.jpeg" alt=""></p>
<p>De afgelopen week heeft eindelijk een gevoel van <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> binnen de bredere cryptogemeenschap, met de langdurige cryptowinter onderbroken door heldergroene candlesticks die de grafieken verlichten. Met mensen zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> versnelt bijna met bijna 25% en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Met een stijging van bijna 20% heeft deze snelle stijging van het bullish momentum zich een weg gebaand door de top 100 en heeft verschillende activa in waarde doen stijgen. In het licht van dit bullish momentum heeft BTC in minder dan een maand bijna één miljoen niet-nuladressen toegevoegd, wat heeft geleid tot meer positieve voorspellingen voor de komende maanden. Het positieve nieuws lijkt echter hier te stoppen, met de aankondiging van internationale mediagigant Playboy dat het meer dan $4,9 miljoen verlies heeft geleden op ETH nadat het de activa begon te accepteren in NFT-betalingen. Ook aan de institutionele zijde heeft de VS de in ballingschap levende Chinese zakenman Guo Wengui gearresteerd nadat hij wordt beschuldigd van betrokkenheid bij meer dan $1 miljard aan crypto-gerelateerde fraude.</p>
<h2 id="h2-Het20laatste20nieuws242314"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-BTC20voegt20bijna2020120miljoen20nietnul20adressen20toe20in20minder20dan20een20maand2589"><a name="BTC voegt bijna $ 1 miljoen niet-nul adressen toe in minder dan een maand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC voegt bijna $ 1 miljoen niet-nul adressen toe in minder dan een maand</h3><p>In iets minder dan een maand, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het netwerk heeft met succes bijna één miljoen portefeuilles aan boord genomen die een saldo hebben dat niet gelijk aan nul is. Na in februari te zijn gedaald van 44,2 miljoen naar 43,8 miljoen, is het aantal portefeuilles met een saldo dat niet gelijk aan nul is versneld naar een nieuw recordhoogte van 44,778 miljoen op 15 maart in een felle herstel. Verschillende analisten speculeren dat de toename van het aantal portefeuilles rechtstreeks correleert met de adoptie van het netwerk, waarbij ervan wordt uitgegaan dat deze toename in portefeuilles een stijgende vraag naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, wat op de lange termijn de waarde ervan kan verhogen.</p>
<p>Echter is deze metriek niet de enige die hoop geeft voor het BTC-netwerk. De zeven-daagse Exponentiële Voortschrijdende Gemiddelde (EMA) van nieuwe adressen die interageren met het BTC-netwerk begon te stijgen sinds de vorige maand, waardoor het zijn hoogste niveau bereikte begin maart sinds midden 2021. Dit duidt erop dat ondanks de crypto winter die de prijsgroei belemmert, er nog steeds ongekende mogelijkheden zijn voor BTC om de komende maanden te groeien, waarbij de gemeenschap schijnbaar sterker is dan ooit.<br><img src="https://gimg2.gateimg.com/image/article/16790257641.jpg" alt=""><br>Afbeelding ter illustratie van BTC (Afbeelding met dank aan Reuters)</p>
<h3 id="h3-Playboy20verliest2049M20aan20ETH20na20acceptatie20van20NFTbetalingen822009"><a name="Playboy verliest $4,9M aan ETH na acceptatie van NFT-betalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Playboy verliest $4,9M aan ETH na acceptatie van NFT-betalingen</h3><p>PLBY Group, het moederbedrijf van Playboy, heeft een verlies van $4.9 miljoen gerapporteerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het vond vorig jaar plaats nadat het begon te faciliteren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> betalingen voor zijn NFT-serie. Dit komt in het licht van het feit dat de cryptomarkt de afgelopen maanden ernstig is verslechterd, waardoor de waardering van de ‘Rabbitars’ NFT-collectie wordt beïnvloed, die in 2021 werd gelanceerd en uiteindelijk Playboy naar verluidt $ 4,9 miljoen kostte.</p>
<p>In recente financiële verslagen stond de waarde van de digitale activa van Playboy op $327.000, een verbijsterend verlies ten opzichte van de gerapporteerde $1,75 miljoen in september 2022. Playboy rechtvaardigde de rekeningen van het bedrijf voor zijn digitale activa als ‘onbepaalde immateriële activa’.<br><img src="https://gimg2.gateimg.com/image/article/16790261122.png" alt=""><br>Playboy-logo (Afbeelding met dank aan Coindesk)</p>
<h3 id="h3-VS20DOJ20arresteert20Guo20Wengui20en20beweert20banden20met20120miljard20cryptofraudeoperatie536273"><a name="VS DOJ arresteert Guo Wengui en beweert banden met $1 miljard crypto-fraude-operatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VS DOJ arresteert Guo Wengui en beweert banden met $1 miljard crypto-fraude-operatie</h3><p>De in ballingschap levende Chinese miljardair, Guo Wengui, werd deze week gearresteerd in New York nadat het Amerikaanse ministerie van Justitie (DOJ) en de Securities and Exchange Commission (SEC) beweerden dat hij betrokken was bij een frauduleus complot van meer dan $1 miljard, inclusief cryptocurrency. Het DOJ heeft Guo aangeklaagd voor 12 glen van draadfraude, effectenfraude, bankfraude en witwassen van geld op verdenking van het werven van investeringen in verschillende entiteiten via valse verklaringen en voorstellingen aan ‘honderdduizenden van [zijn] online volgers’.</p>
<p>Het DOJ heeft beweerd dat Guo, samen met andere verdachten, meer dan $262 miljoen aan slachtofferfondsen heeft verkregen via de Himalaya Exchange, een cryptocurrency-ecosysteem, en verder verklaard dat de collectieve ongeveer $634 miljoen heeft verkregen van 21 verschillende bankrekeningen die verband houden met de vermeende fraude.<br><img src="https://gimg2.gateimg.com/image/article/16790239823.png" alt=""><br>Guo Wengui (Afbeelding met dank aan NY Times)</p>
<h2 id="h2-Huidige20projecttrends754730"><a name="Huidige projecttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige projecttrends</h2><p>Op basis van gegevens van CoinMarketCap was het best scorende project van de afgelopen week BitTube, een multimediaal beloningsproject dat bestaat uit verschillende producten die de betrokkenheid van gebruikers bij elk type betaling willen stimuleren. Als gevolg hiervan is BitTube de afgelopen 24 uur met 139% versneld en de afgelopen week met maar liefst 483%.</p>
<h2 id="h2-De20huidige20BTCtrend579330"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p><img src="https://gimg2.gateimg.com/image/article/16790240664.png" alt=""><br>Wekelijks <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">btc prijs</a> Gegevens (Gegevens met dank aan Coinmarketcap)</p>
<p>Gedurende de afgelopen week, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef in een horizontaal handelstraject voor het begin van de week, nadat het de week was begonnen op een dieptepunt van $20,9k. Na een korte dip onder zijn 7-daagse SMA begon BTC boven deze drempel te herstellen en geleidelijk naar de $21k-zone te bewegen tegen de 13e. Op de 13e begon BTC echter enige significante momentum te winnen en steil omhoog te klimmen en in de $23k-zone te duwen. Op de 14e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bereikte een meermaands hoogtepunt van $26.514,72 en begon matig te dalen, waardoor het de week afsloot op een veelbelovende $25,41k.</p>
<p>Naast deze bullish momentum, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is onderhevig geweest aan een toename van zelfbewaarde holdings als gevolg van het instorten van verschillende crypto-bank- en beursinstellingen. Met toenemende zorgen in de banksector is er sinds de ineenstorting van Silvergate Bank vorige week meer dan 70.000 BTC opgenomen in zelfbewaarde portefeuilles. De overstap naar zelfbewaring geeft aan dat, ondanks groeiende zorgen met betrekking tot de actoren binnen de markt, investeerders nog steeds vasthouden aan de ethiek van crypto en nog steeds geïnteresseerd zijn in het nastreven van investeringen.</p>
<p>In het licht hiervan, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De MVRV (marktwaarde ten opzichte van gerealiseerde waarde) van BTC bereikte aan het begin van de week een dieptepunt van 1,077. Gedurende de rest van de week steeg het steil en bereikte het een hoogtepunt van 1,137. Dit suggereert dat de waardering van BTC eindelijk begint af te wijken van het ondergewaardeerde gebied en dat de werkelijke waarde ervan wordt gerealiseerd.<br><img src="https://gimg2.gateimg.com/image/article/16790241255.png" alt=""><br>7-daagse BTC MVRV-gegevens (Gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20situatie20van20ETH20staking574619"><a name="De situatie van ETH staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De situatie van ETH staking</h2><p>Met ingang van 17 maart, de staat van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staking blijft relatief positief, waarschijnlijk door de aanstaande implementatie van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Shanghai-upgrade, waardoor alle validatoren die hebben gestaked worden ingeschakeld. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> hun tokens geleidelijk inlossen en de daaropvolgende opbrengst verdienen. Bovendien neemt het volume van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het aantal gedeponeerde tokens op de Beacon Chain is sinds het begin van 2023 gestaag toegenomen en begint in maart een merkbare stijging te laten zien.<br><img src="https://gimg2.gateimg.com/image/article/16790243536.png" alt=""><br>(Gegevens met dank aan Dune)</p>
<p>Hier zijn enkele belangrijke cijfers van de afgelopen week om dit te consolideren:</p>
<p>Totaal aantal validators: 512.657<br>Depositor adressen: 90.200<br>Totaal ETH gestort: 16.353.927<br>Percentage liquide staking: 35,60%<br>Aandeel van gestakede ETH in aanbod: 14,70%</p>
<h2 id="h2-De20huidige20macrosituatie704157"><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-Internationale20gas20en20olieprijzen20dalen20naarmate20economisch20perspectief20verbetert628972"><a name="Internationale gas- en olieprijzen dalen naarmate economisch perspectief verbetert" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Internationale gas- en olieprijzen dalen naarmate economisch perspectief verbetert</h3><p>Het afgelopen jaar is gemeld dat de internationale gas- en olieprijzen aanzienlijk zijn gedaald als gevolg van een relatief milde winter en verminderde vraag. Verschillende analisten hebben geopperd dat de daling van de prijzen de wereldeconomie kan behoeden voor verdere gevaar, maar het is belangrijk om voorzichtig te zijn, omdat het effect van renteverhogingen nog niet echt voelbaar is op internationaal niveau.</p>
<h2 id="h2-Wat20zou20er20in20de20komende20week20kunnen20komen427440"><a name="Wat zou er in de komende week kunnen komen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zou er in de komende week kunnen komen?</h2><p>Met de crypto winter die schijnbaar tijdelijk verstoord is, lijkt het erop dat de crypto markt een positieve week voor de boeg heeft aangezien de markt worstelt met neerwaartse druk en een bullish surge. Met de marktkapitalisatie die met bijna $200 miljoen is gestegen van de vorige week tot $1.1T, kan de markt in de buurt komen van herstel. Toch is het belangrijk om voorzichtig te zijn, met name vanwege de intense volatiliteit die de afgelopen maand binnen de markt is gezien, die het crypto-toneel van multi-maandelijkse dieptepunten naar hoogtepunten heeft geslingerd.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io Onderzoeker: <strong>Matthew Webster-Dowsing</strong><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 opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle andere glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>