TWFya3R0cmVuZO+9nEJsb2NrRmkgdmVya29vcHQgJDQsNyBtaWxqb2VuIGFhbiBtaWpuYm91d2FwcGFyYXR1dXIgdGlqZGVucyBmYWlsbGlzc2VtZW50LCBCcmlhbiBBcm1zdHJvbmcgaGFhbHQgdWl0IG5hYXIgQW1lcmlrYWFuc2UgY3J5cHRvcmVndWxlcmluZyBvcCBUd2l0dGVy

2023-03-24, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/167843662920230310-162305.jpeg" alt=""><br>Gedurende de afgelopen week is de meerderheid van de cryptocurrency markt optimistisch gebleven, met groene candlesticks die veel voorkomen in de top 100. Hoewel er onvermijdelijk enkele uitzonderingen zijn op deze bullish trend, zijn de verliezen die door deze activa zijn opgebouwd voornamelijk onder de 1% gebleven, wat suggereert dat de trend van herstel zich lijkt uit te breiden naar deze week en mogelijk de volgende.</p>
<p>In de afgelopen week hebben onder meer <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, en <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> We hebben allemaal groeispurten meegemaakt van wel 21%, wat het vertrouwen in de huidige koers van de markt enigszins heeft hersteld. Ondanks deze positieve prijsvooruitzichten blijft de institutionele kant van crypto echter zeer bearish en controversieel. Met het faillissement van BlockFi in volle gang, wordt gemeld dat ze meer dan $4,7 miljoen aan tastbare mijnbouwapparatuur gaan verkopen. Wat betreft een andere institutionele noot, heeft de CEO van Coinbase, Brian Armstrong, zijn frustraties geuit op Twitter over de regelgeving van de SEC met betrekking tot cryptocurrencies in de Verenigde Staten. Daarnaast heeft een recent rapport van Hindenburg licht geworpen op Jack Dorsey’s Block (een betalingsdienstverlener) door het een ‘veilige haven voor criminelen’ te noemen.</p>
<h2 id="h2-Het20laatste20nieuws750013"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-BlockFi20verkoopt204720miljoen20aan20mijnbouwapparatuur20tijdens20faillissement765242"><a name="BlockFi verkoopt $4,7 miljoen aan mijnbouwapparatuur tijdens faillissement" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlockFi verkoopt $4,7 miljoen aan mijnbouwapparatuur tijdens faillissement</h3><p>Met het faillissementsproces van BlockFi in volle gang heeft een faillissementsrechter de verkoop van BlockFi’s crypto mining apparatuur en soortgelijke fysieke activa goedgekeurd, met een totale waarde van $4,7 miljoen. Op donderdag werden deze activa verkocht aan een partij onder de naam U.S. Farms, die deelnam aan een ‘zeer competitief’ veilingproces dat vijf biedingen opleverde voor het volledige mijnbouw-activapakket, evenals zeven extra gedeeltelijke biedingen, in overeenstemming met een verklaring van een advocaat.</p>
<p>Als een van de belangrijkste aanbieders van leningen te zijn geweest in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Naar verluidt zijn de leningen van $160 miljoen in de mijnbouwsector die voorheen te koop waren, nu mogelijk aanzienlijk ondergecollateraliseerd als gevolg van de aanzienlijke daling van de prijzen van ASIC-machines. Dit kwam aan het licht toen de Bitcoin-prijzen eind vorig jaar scherp daalden, terwijl de energiekosten internationaal begonnen te stijgen. Als gevolg hiervan zijn bedrijven zoals BlockFi gedwongen tot liquidatie.<br><img src="https://gimg2.gateimg.com/image/article/16796290721.png" alt=""><br>BlockFi Illustratieve Afbeelding (Afbeelding met dank aan CoinMarketCap)</p>
<h3 id="h3-Brian20Armstrong20neemt20zijn20toevlucht20tot20Twitter20om20de20Amerikaanse20cryptoregelgeving20af20te20keuren751704"><a name="Brian Armstrong neemt zijn toevlucht tot Twitter om de Amerikaanse crypto-regelgeving af te keuren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brian Armstrong neemt zijn toevlucht tot Twitter om de Amerikaanse crypto-regelgeving af te keuren</h3><p>Tijdens een ‘Twitter Space’ gehost door Coinbase eerder deze week, gaf CEO Brian Armstrong het startschot voor de ruimte door te verwijzen naar de Wells Notice, waarbij hij aanvankelijk verklaarde: ‘we dachten niet dat dit onverwacht was, om eerlijk te zijn’. Hij benadrukte vervolgens dat Coinbase graag de regels wil naleven via hun ‘compliance-first aanpak’, terwijl ze de brug slaan tussen crypto en fiat. Armstrong verklaarde echter dat ‘de SEC een instelling is waar we de afgelopen jaren echt mee hebben geworsteld’ in verwijzing naar de pogingen van Coinbase om het regelgevingslandschap te bespreken, met uitzondering van de oproep van de SEC aan het bedrijf vorig jaar.</p>
<p>Armstrong onthulde dat Coinbase naar verluidt meer dan 30 vergaderingen heeft gehad ‘in de afgelopen negen maanden’ met de SEC in een poging om uit te monden in een vergadering waarin regelgevende feedback zou worden gegeven. Armstrong beweerde echter dat de SEC de vergadering de dag ervoor had geannuleerd en een week later een Wells Notice had ingediend. Armstrong drong erop aan dat ‘we hebben gevraagd om officiële regels op te stellen’ en bevestigde dat Coinbase heeft geprobeerd om proactief nalevingsvergunningen te verkrijgen, maar de vergunningen liggen nog steeds stil. In een gedurfde verklaring suggereerde Armstrong dat de VS het verst achterloopt op het gebied van cryptoregulering, omdat andere landen actief de groei van cryptobedrijven bevorderen, terwijl de VS dat niet doen.<br><img src="https://gimg2.gateimg.com/image/article/16796384062.png" alt=""><br>Brian Armstrong (Afbeelding met dank aan CNBC)</p>
<h3 id="h3-Hindenburgrapport20onthult20dat20Block20een20toevluchtsoord20voor20criminelen20is240001"><a name="Hindenburg-rapport onthult dat Block een ‘toevluchtsoord voor criminelen’ is" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hindenburg-rapport onthult dat Block een ‘toevluchtsoord voor criminelen’ is</h3><p>Een recent Hindenburg-rapport beweert enkele schokkende waarheden te hebben ontdekt over de betalingsprovider van Jack Dorsey, Block Inc., na het uitvoeren van een twee jaar durend onderzoek. Hindenburg beweerde dat Block de gebruikersstatistieken opdreef en dat insiders de top verkochten. Als gevolg hiervan bestempelde Hindenburg het bedrijf als het faciliteren van ‘wrijvingsloze’ fraude, aangezien insiders naar verluidt $ 1 miljard uitbetaalden.</p>
<p>Volgens het jaarverslag van Block over 2022 hebben ze meer dan 51 miljoen maandelijkse ‘actieve gebruikers’, maar voormalige werknemers vertelden Hindenburg dat 40-75% van deze accounts nep is, betrokken is bij fraude of extra accounts van bestaande gebruikers. Hindenburg heeft beweerd dat de cash-app een ‘veilige haven’ is voor criminelen, verder ondersteund door een vermeende verklaring van een medewerker die verklaarde dat “elke crimineel een Square Cash App-account heeft”. Hindenburg beweert dat druk van het hogere management heeft geleid tot het negeren van antiwitwaswetten (AML) en know-your-customer (KYC).<br><img src="https://gimg2.gateimg.com/image/article/16796384383.png" alt=""><br>Block CEO, Jack Dorsey (Afbeelding met dank aan WWD)</p>
<h2 id="h2-Huidige20projecttrends169872"><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 project met de grootste winst in de afgelopen week Aion, een token dat wordt gebruikt om veilig toegang te krijgen tot The Open Application Network (OAN), een Canadees openbaar netwerk dat voor iedereen beschikbaar is. Als gevolg hiervan is Aion in de afgelopen 24 uur met 521% versneld en is het totaal in de afgelopen week verbazingwekkend met 329,69% gestegen.</p>
<h2 id="h2-De20huidige20BTCtrend917618"><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/16796291634.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> is blijven handelen langs een opwaartse traject, resulterend in een stijging van 12.88%. Aan het begin van de week stond het op 24.97k. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> schoot direct omhoog naar het gebied van $26k gedurende de 17e en begon zich te verplaatsen naar het gebied van $27k gedurende de 18e en 19e. Op de 20e, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Begon door de $28k drempel te duwen, waardoor het tussen $27.5k en $28.3k volleyde tot de 22e, toen het vervolgens naar beneden stortte naar $26.7k. BTC begon echter snel wat terrein terug te winnen, wat leidde tot opnieuw omhoog schieten op de 23e terug in de $28k zone. Dit heeft geleid tot BTC bereiken $28.73k op het moment van schrijven.</p>
<p>In het licht hiervan, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De MVRV (marktkapitalisatie ten opzichte van gerealiseerde waarde) van BTC is deze week versneld. Aan het begin van de week stond de MVRV op 1,391 en steeg deze steil gedurende de hele week, met een piek van 1,421 op de 22e, voordat deze begon te dalen. Dit suggereert dat de waardering van BTC blijft bewegen van het onderverkochte gebied en dat de werkelijke waarde ervan wordt gerealiseerd.<br><img src="https://gimg2.gateimg.com/image/article/16796291795.png" alt=""><br>7-Daagse BTC MVRV-gegevens (gegevens vriendelijk verstrekt door Blockchain.com)</p>
<h2 id="h2-De20situatie20van20ETH20Staking844321"><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>Vanaf 24 maart, de staat van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staking blijft positief, voornamelijk vanwege 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 toegestaan <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> om geleidelijk hun tokens in te wisselen en de daaropvolgende opbrengst te verdienen. Bovendien neemt het volume van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De storting op de Beacon Chain is sinds het begin van 2023 blijven groeien met een steil tempo, waarbij dit een stijging begint te zien gedurende maart.<br><img src="https://gimg2.gateimg.com/image/article/16796292026.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>Vloeibare staking percentage: 35,63%<br>Gestorte aandeel van ETH-aanbod: 14,81%</p>
<h2 id="h2-De20Huidige20Macrosituatie837228"><a name="De Huidige Macrosituatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Huidige Macrosituatie</h2><h3 id="h3-China20zal20naar20verwachting204020van20de20stijging20in20de20wereldwijde20olievraag20in20202320opvangen20aldus20Wood20Mackenzie175912"><a name="China zal naar verwachting 40% van de stijging in de wereldwijde olievraag in 2023 opvangen, aldus Wood Mackenzie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>China zal naar verwachting 40% van de stijging in de wereldwijde olievraag in 2023 opvangen, aldus Wood Mackenzie</h3><p>In een recent rapport van Wood Mackenzie werd opgemerkt dat ‘een terugkeer naar normale mobiliteit in China de grootste vraagstimulator is, goed voor 1 miljoen vaten per dag (b/d) van de toename van 2,6 miljoen b/d dit jaar’. Dit komt in het licht van de vertraging van renteverhogingen, waardoor China mogelijk goed is voor ongeveer 40% van het wereldwijde herstel van de vraag naar de grondstof.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week436908"><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>Naarmate de cryptomarkt blijft verbeteren qua waardering en volume, is het waarschijnlijk dat deze momentum zal doorzetten in de komende week. Echter, met de uitstroom van bearish institutioneel nieuws, is het mogelijk dat deze verzameling van gegevens en nieuwsberichten in de markt begint door te sijpelen en een bearish sentiment creëert.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw posten van het artikel is toegestaan 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>