TWFya3R0cmVuZO+9nEJpdGNvaW4gTWluZXIgUmlvdCBtZWxkdCBzdGlqZ2luZyB2YW4gZGUgb3V0cHV0LCBSdXNzaXNjaGUgYmFuayBnZWVmdCBPbi1DaGFpbiBCYW5rZ2FyYW50aWUgdWl0IGluIENoaW5lc2UgeXVhbg==

2023-03-03, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>In de afgelopen week is de cryptocurrency markt voornamelijk begonnen met dalen, met rode kaarsen die veel voorkwamen gedurende de afgelopen week. Dit heeft geleid tot verliezen tot 15% binnen de top 100, waarbij er weinig afwijking is van deze negatieve trend.</p>
<p>In lijn met deze bearish sentiment, zijn de leden van het South Dakotan huis van afgevaardigden op zoek naar een wijziging van de UCC om het gebruik van cryptocurrencies te verbieden, maar dit geldt niet voor het gebruik van CBDC’s, wat tot grote verontwaardiging heeft geleid onder cryptogemeenschappen. Afwijkend van dit bearish sentiment heeft BTC miner Riot Platforms, Inc. een opmerkelijke stijging van de output en een verdrievoudiging van hun hash-snelheid gemeld gedurende 2022. Op dezelfde manier heeft een van de grootste banken van Rusland, Moscow Credit Bank, een op blockchain gebaseerde bankgarantie uitgegeven in de Chinese yuan, waarbij dit wordt gepresenteerd als de eerste in het land.</p>
<h2 id="h2-Het20laatste20nieuws209195"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-Bitcoin2020Miner20Riot20meldt20stijging20van20de20output518827"><a name="Bitcoin  Miner Riot meldt stijging van de output" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Miner Riot meldt stijging van de output</h3><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Mining-krachtpatser, Riot Platforms, Inc., heeft een omzet van $259,2 miljoen gerapporteerd voor 2022, wat wordt toegeschreven aan de toegenomen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> productie en een heel jaar inkomsten uit hosting en engineering. De miner heeft in totaal 5.554 BTC geproduceerd, een stijging van 46% ten opzichte van het voorgaande jaar, wat Riot heeft verklaard als het resultaat van hun ‘toonaangevende financiële kracht’, waardoor het in een sterke positie verkeert om zijn ‘agressieve groeiplannen’ voort te zetten. Daarnaast heeft Riot ook gemeld dat ze hun hash rate capaciteit hebben verdrievoudigd.</p>
<p>Aan de andere kant daalde de mijnbouwopbrengst van Riot, toch heeft de CEO van Riot, Jason Les, de daling van de waarde van BTC aangehaald als de reden voor deze daling. Echter, als gevolg van een boekhoudkundige wijziging met betrekking tot de manier waarop BTC op de balans wordt weergegeven, meldde Riot in een indiening bij de SEC dat de voormalige financiële overzichten voor 2020 en 2021 ‘niet langer moeten worden vertrouwd’, maar dit zal worden gewijzigd in een 10-K-indiening voor 2022.<br><img src="https://gimg2.gateimg.com/image/article/16778144101.png" alt=""><br>Gebouw F, een BTC-mijnbouwgebouw in de faciliteit van Riot (afbeelding met dank aan Bloomberg)</p>
<h3 id="h3-South20Dakotan20Voorgestelde20UCCwijziging20verbiedt20crypto325823"><a name="South Dakotan Voorgestelde UCC-wijziging verbiedt crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>South Dakotan Voorgestelde UCC-wijziging verbiedt crypto</h3><p>De Republikein uit South Dakotan, Mike Stevens, heeft onlangs een amendement van 117 pagina’s ingediend bij het Huis van Afgevaardigden dat tot doel heeft de Uniform Commercial Code (UCC) te wijzigen om de definitie van geld te beperken om cryptocurrencies uit te sluiten. CBDC’s zullen onder deze wetgeving echter nog steeds worden gedefinieerd als ‘geld’, wat een soort voorbehoud is bij deze motie. Stevens heeft geld gedefinieerd als een ‘ruilmiddel dat momenteel is geautoriseerd of aangenomen door een binnenlandse of buitenlandse overheid’, maar specificeerde verder dat de ‘term geen elektronisch record omvat’, met name een die actief was vóór de autorisatie en goedkeuring van de overheid.</p>
<p>Deze wet contrasteert sterk met de recente ‘CBDC Anti-Surveillance State Act’ die door de Republikeinse Tom Emmer uit Minnesota aan het Huis van Afgevaardigden is voorgesteld, die vaak wordt gezien als een voorstander van crypto. Als gevolg van het voorstel van Steven hebben veel politici en crypto-figuren zich op internet uitgesproken tegen de toenemende belangstelling van de Amerikaanse regering voor CBDC’s en het afwijzen van bredere cryptocurrencies.<br><img src="https://gimg2.gateimg.com/image/article/16778144452.png" alt=""><br>Anti-Crypto Illustrative Art (Afbeelding met dank aan Asia Blockchain Review)</p>
<h3 id="h3-Russische20bank20geeft20onchain20bankgarantie20in20Chinese20yuan421461"><a name="Russische bank geeft on-chain bankgarantie in Chinese yuan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Russische bank geeft on-chain bankgarantie in Chinese yuan</h3><p>Eerder deze week heeft Moscow Credit Bank een unieke op blockchain gebaseerde bankgarantie uitgegeven die is uitgedrukt in de Chinese yuan. De bankgarantie overtreft 100 miljoen Chinese yuan (of $114.600 op het moment van schrijven). De transactie werd uitgevoerd via het Masterchain blockchain-platform, het Russische nationale blockchain-netwerk dat nationale digitale overdrachten vergemakkelijkt. Deze bankgarantie wordt verwacht te dienen als een financiële waarborg in het geval van leenoperaties, maar als er onder de garantie een betaling wordt gedaan, ontvangt de begunstigde Russische roebels tegen de overeengekomen wisselkoers van de organiserende partijen, ondanks dat de garantie aan de yuan is gekoppeld.</p>
<p>Dit initiatief voor grensoverschrijdende adoptie van cryptocurrency komt naar voren nu de centrale bank van Rusland zich voorbereidt om op 1 april van dit jaar de eerste consumentenproef voor haar CBDC te lanceren. De digitale roebel zal naar verwachting worden gefaciliteerd door 13 lokale banken en verschillende handelaren in het hele land.<br><img src="https://gimg2.gateimg.com/image/article/16778144803.png" alt=""><br>Masterchain Logo (Afbeelding met dank aan TAdviser)</p>
<h2 id="h2-Huidige20projecttrends540683"><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 was het best presterende project van de afgelopen week gericht op het integreren van toepassingsscenario’s op verschillende gebieden en vanuit meerdere perspectieven, om manieren te zoeken waarop blockchaintechnologie problemen kan aanpakken en oplossen binnen een groot aantal netwerken, waarbij deze netwerken niet in staat zijn om ze op te lossen. Dit activum wordt Orient Walt genoemd en is in één dag met maar liefst 113,28% gestegen, waardoor het is gestegen tot $0,017.</p>
<h2 id="h2-De20Huidige20BTC20Trend444426"><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/16778145334.png" alt=""><br>Wekelijks <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">btc prijs</a> Gegevens (Gegevens met dank aan Blockchain.com)</p>
<p>Gedurende de afgelopen week, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is onderhevig geweest aan immense volatiliteit die het onder zijn 7-daagse SMA heeft gedreven en het van de $24k regio naar een wekelijkse dieptepunt van $22.898,30 heeft doen duiken. Gelukkig begon BTC zijn positie boven deze regio te herwinnen en verder te bewegen naar de $23.5k, waardoor het gemiddeld voor $23.49k verhandeld werd gedurende de week, waarbij BTC op deze waarde sloot op de 2e.</p>
<p>De huidige prijsontwikkeling van BTC lijkt erop te wijzen dat het verder weg begint te vallen van de weerstandszones van $25k en mogelijk $24k vestigt als zijn nieuwe wekelijkse weerstand. Dit suggereert dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Daalt geleidelijk en corrigeert mogelijk, waardoor het wordt verhandeld tussen $22,8k en $23,5k.</p>
<p>In het licht hiervan, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de MVRV (marktkapitalisatie naar gerealiseerde waarde) begon de week met een relatief horizontaal groeipercentage, wat wijst op een korte periode van stagnatie. Aan het einde van februari, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De MVRV van BTC begon scherp te stijgen, van een gemiddelde van 1.175 naar een wekelijkse hoogte van 1.18. Dit is echter een opmerkelijke afname ten opzichte van de voorgaande week, waarin de MVRV van BTC het 1.2-gebied verkende, wat suggereert dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De waarde van is opnieuw in de buurt van onderverkochte en ondergewaardeerde gebieden.<br><img src="https://gimg2.gateimg.com/image/article/16778145555.png" alt=""><br>5-daagse BTC MVRV-gegevens (Gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20situatie20van20ETHstaking950764"><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>Op 2 maart was de situatie van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staking blijft relatief positief, vooral gezien de aanstaande <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Shanghai-upgrade, die alle validators die gestaked hebben zal belonen <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> hun tokens geleidelijk vrij te geven en vervolgens verdiende opbrengst. Daarnaast het volume van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het aantal gedeponeerde munten op de Beacon Chain blijft sinds het begin van 2023 in een relatief snel tempo groeien, en dit is doorgegaan tot begin maart.<br><img src="https://gimg2.gateimg.com/image/article/16778145766.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,38%<br>Aandeel ETH-aanbod gestaked: 14,49%</p>
<p>Naast het bovenstaande is de interesse van de bredere cryptocurrency- en financiële markt in liquide derivaten enorm gestegen, waardoor de LDO-governancetoken (de inheemse token van de DAO achter de liquid staking-provider Lido) met 33% is gestegen en zijn concurrent, RPL, (de inheemse token van <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> te stijgen met 18%. Dit is waarschijnlijk te wijten aan hun cruciale rol bij het verlagen van de toegankelijkheidsdrempels voor individuen om hun <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, door gebruikers in staat te stellen elk bedrag aan Ether in te zetten, waarmee dit wordt toegewezen aan een specifieke validator totdat het vereiste bedrag aan Ether is bereikt.</p>
<h2 id="h2-De20huidige20macrosituatie183349"><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-VAE20gedentificeerd20als20land20van20focus20terwijl20de20VS20zich20richt20op20Russische20economische20partners985162"><a name="VAE geïdentificeerd als ‘land van focus’ terwijl de VS zich richt op Russische economische partners" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VAE geïdentificeerd als ‘land van focus’ terwijl de VS zich richt op Russische economische partners</h3><p>In de afgelopen dag is het algemeen bekend geworden dat de VS naar de VAE zijn gaan kijken als een ‘land van focus’ terwijl het de banden van Rusland met de wereldeconomie onderdrukt. Elizabeth Rosenberg, de adjunct-minister van Financiën voor terrorismefinanciering en financiële misdrijven, verklaarde: “We maken ons specifiek zorgen over de toename van de handel met Rusland in het soort goederen dat op het slagveld kan worden gebruikt en degenen die aangewezen Russische entiteiten helpen.” Deze opmerkingen komen in het licht van de groeiende bezorgdheid in het Westen dat de VAE, naast landen als Turkije, fungeren als de kritieke economische levensader van Rusland nu het conflict tussen Rusland en Oekraïne uitbreekt.</p>
<p>Er werd gemeld dat de VAE goederen exporteerde, inclusief door de VS gecontroleerde goederen zoals ‘halfgeleiderapparaten’, die 30% van de totale waarde van al hun export vertegenwoordigden en waarvan het Westen denkt dat ze op het slagveld kunnen worden gebruikt. Als gevolg hiervan is Washington naar verluidt ‘steeds meer gefrustreerd’ geraakt door het zakelijke model van de VAE en is het van plan harder op te treden tegen de natie.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week104547"><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 markt die deze week een negatief sentiment draagt, is het waarschijnlijk dat dit zich in de komende week zal voortzetten, toch lijkt de onderliggende waarderingstraject voor een meerderheid van activa in de top 100 indicatief te zijn van een progressieve en geleidelijke toename op een 3-maandelijkse schaal, wat duidt op een progressief stijgende marktwaardering op lange termijn.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 andere gevallen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>