TWFya3R0cmVuZCB8IERlIExheWVyLTIgdmFuIENvaW5iYXNlIGhlZWZ0IGVlbiBtb2VpemFtZSB1aXRyb2w7IENpcmNsZSBDRU8gbmVlbXQgaGV0IG9wIHRlZ2VuIGRlIFNFQyBkaWUgd2lsIGluZ3JpanBlbiBiaWogc3RhYmxlY29pbnM=

2023-02-24, 03:24

<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>De afgelopen week heeft de cryptocurrency markt een gemengd beeld laten zien van positieve prijsstijgingen en geleidelijke dalingen. Binnen de top 10 zijn de meeste activa begonnen tot 5% van hun totale waarde te verliezen, maar de rest van de top 100 lijkt nog steeds te profiteren van de recente bullish momentum, waarbij velen stijgingen tot wel 40% zien. Als gevolg hiervan heeft de huidige wereldwijde crypto-marktkapitalisatie $1,1 miljard bereikt, een stijging van $200 miljoen in vergelijking met de vorige week.</p>
<p>In het licht van deze gemengde marktsentimenten heeft Coinbases’s zeer verwachte layer-2 blockchain, Base, een rotsachtige eerste release gehad, waarbij klachten over het internet opduiken. Op een vergelijkbaar onderwerp heeft de CEO van Circle, Jeremy Allaire, een standpunt ingenomen tegen de SEC die regelgeving voor stablecoins voorstelt en in plaats daarvan suggereert dat een andere toezichthouder hun plaats inneemt. Aan de institutionele kant is Colombia een van de eerste landen die een volledig virtuele rechtbankzitting organiseert met behulp van de Metaverse van Meta.</p>
<p>Met deze reeks nieuws is het waarschijnlijk dat in de komende week discussies over regelgeving zullen plaatsvinden, waarbij toezichthouders en vakmensen uit de sector zich aan beide kanten zullen laten horen. Bovendien is het waarschijnlijk dat Coinbase gebruikerszorgen zal beginnen aan te pakken en zich zal aanpassen om de levensvatbaarheid van de Base blockchain te waarborgen.</p>
<h2 id="h2-Het20laatste20nieuws394539"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-Coinbases20Layer220heeft20een20hobbelige20uitrol380986"><a name="Coinbase’s Layer-2 heeft een hobbelige uitrol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coinbase’s Layer-2 heeft een hobbelige uitrol</h3><p>De lancering van Coinbase’s Layer-2 blockchain, Base, is de afgelopen maanden zeer verwacht, maar de initiële testnet-implementatie deze week is relatief problematisch gebleken. Slechts enkele uren na de release werd het netwerk geconfronteerd met een reeks problemen, waardoor gebruikers massaal naar sociale media gingen om te reageren op de functionaliteit van het netwerk. Met operationele problemen, zoals onbevestigde en teruggedraaide transacties, die het platform teisteren, gaf Coinbase een verklaring waarin werd erkend dat deze operationele problemen te wijten waren aan een probleem met hun interne wallets die de vereiste gas verkeerd inschatten om gebruikerstransacties uit te voeren.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het op ontwikkelaars gerichte protocol streeft ernaar een belangrijke rol te spelen in de strategie van Coinbase om zijn bedrijfsmodel te verplaatsen naar de ontwikkelaarsruimte, omdat de uitwisselingsactiviteit en kwartaalwinsten het afgelopen jaar zijn afgenomen.</p>
<h3 id="h3-Circle20CEO20neemt20stelling20tegen20de20SEC20die20zich20wil20gaan20reguleren20op20stablecoins76156"><a name="Circle CEO neemt stelling tegen de SEC die zich wil gaan reguleren op stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Circle CEO neemt stelling tegen de SEC die zich wil gaan reguleren op stablecoins</h3><p>De CEO en oprichter van Circle, Jeremy Allaire, heeft onlangs een verklaring afgelegd waarin hij commentaar gaf op de rol van de SEC bij de regulering van stablecoins. Allaire merkte op dat de SEC niet de ‘juiste toezichthouder’ is voor stablecoins en dat de activiteiten van een betalingsfaciliterende stablecoin, zoals USDC, vallen onder het toezicht van een bankentoezichthouder, in plaats van een beleggingstoezichthouder.</p>
<p>Allaire was er snel bij om te verduidelijken dat hij ‘aan boord’ is met het voorstel van de SEC om virtuele valuta te onderwerpen aan de eis van gekwalificeerde bewaarders en dat hij niet tegen regulering als geheel is. Allaire merkte op: “Er zijn veel smaken, zoals we graag zeggen, niet alle stablecoins zijn gelijk gemaakt. Maar vanuit een beleidsmatig perspectief is de eenduidige visie over de hele wereld dat dit een betalingssysteem is, in de ruimte van prudentieel toezicht.”. Allaire’s opmerkingen komen naar voren in het licht van veel spelers in de branche die de SEC ervan beschuldigen ‘haar jurisdictie te overschrijden’ wanneer ze proberen in te grijpen in de bredere cryptocurrency-wereld.<br><img src="https://gimg2.gateimg.com/image/article/16772088191.png" alt=""><br>Jeremy Allaire (Afbeelding met dank aan Protocol)</p>
<h3 id="h3-Colombia20wordt20een20van20de20eerste20landen20die20een20rechtszitting20in20de20metaverse20organiseert585644"><a name="Colombia wordt een van de eerste landen die een rechtszitting in de metaverse organiseert" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Colombia wordt een van de eerste landen die een rechtszitting in de metaverse organiseert</h3><p>Colombia werd vorige week een van de eerste landen die gebruik maakte van het brein van Mark Zuckerberg, Meta, om officiële vergaderingen en rechtszittingen te houden. Wetshandhavers in Colombia maakten gebruik van Horizon Workrooms, een Meta-platform dat teams in staat stelt samen te werken via virtuele werkruimtes, om een ​​twee uur durende hoorzitting te houden. De hoorzitting werd uitgezonden op YouTube, waarbij alle deelnemers gebruik maakten van virtuele headsets om deel te nemen.</p>
<p>Als gevolg van de hoorzitting werd er een klacht ingediend om de politie aan te klagen, ondanks dat de hoorzitting over het algemeen succesvol was. Echter, de rechter van de rechtbank van Magdalena, Maria Victoria Quinones Triana, verklaarde: ‘Het gebruik van informatietechnologie bij de ontwikkeling van gerechtelijke procedures heeft als essentieel doel het vergemakkelijken en versnellen van deze processen [van gerechtigheid].’; wat suggereert dat virtuele hoorzittingen in de nabije toekomst een vast onderdeel kunnen worden in heel Colombia.<br><img src="https://gimg2.gateimg.com/image/article/16772088542.png" alt=""><br>Rechtszitting Metaverse Colombia (Afbeelding met dank aan Decrypt)</p>
<h2 id="h2-Huidige20projecttrends345496"><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 gericht op het Python-programmeerscript. Bismuth, dat alleen al in de afgelopen dag een stijging van bijna 420% heeft gezien, beweert het eerste Python blockchain-platform te zijn dat volledig digitaal nut mogelijk maakt. Als gevolg hiervan heeft het de aandacht getrokken van verschillende investeerders en schoot het omhoog van minder dan $ 0,028 naar $ 0,15.</p>
<h2 id="h2-De20huidige20BTCtrend4835"><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/16772089023.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> heeft enorme volatiliteit ondergaan die ervoor zorgde dat het van net onder zijn 7-daagse SMA van $ 23,84k naar een wekelijks hoogtepunt van $ 25,15k steeg. Vanaf dit hoogtepunt begon BTC geleidelijk te dalen door de $ 24k-regio en opnieuw in de bovengrenzen van de $ 23k-regio te dalen voordat het gemiddelde op $ 24k kwam tegen de 24e. Ondanks deze gemengde prestaties, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De prestaties van deze week zijn in lijn met de driemaandelijkse prijsstijging die het zag stijgen van $16,63k tot $25k.</p>
<p>De huidige prijsrichting van BTC lijkt erop te wijzen dat het voortdurend tegen de weerstandszone van $25k aandrukt en zich verwijdert van de regio van de lage $20.000. Gezien BTC deze week niet is afgeweken van de progressieve opwaartse trend, is het waarschijnlijk dat dit zich zal uitstrekken tot de komende week en het potentieel zal bieden om verder tegen de weerstandszone aan te drukken en mogelijk te stabiliseren in de $25k zone.</p>
<p>In het licht hiervan, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De MVRV (marktwaarde-gerelateerde waarde) van BTC is de afgelopen week blijven stijgen. Bij aanvang van de week stond de MVRV op een bescheiden 1,221, maar begon snel te stijgen en bereikte op de 21e het hoogste niveau sinds 2023, met een totaal van 1,246. Dit geeft aan dat… <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beweegt zich verder in het gebied van de gerealiseerde marktwaarde en er is nog ruimte voor groei voordat het in het oversold-gebied komt, wat betekent dat er potentieel is om door de $25k zone heen te breken.<br><img src="https://gimg2.gateimg.com/image/article/16772089284.png" alt=""><br>12-daagse BTC MVRV-gegevens (gegevens met dank aan Blockchain.com)</p>
<h2 id="h2-De20staat20van20ETHgasvergoedingen72215"><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 24 februari is er een matige daling van het totale volume gas dat in de afgelopen week is gebruikt in vergelijking met de voormalige, waarbij het hoogste cijfer op de 20e werd bereikt, met een totaal van 107.889.731.637. Het laagste cijfer dat deze week werd bereikt, was op de 17e, met een totaal van 107.246.290.313, wat een vergelijkbaar totaal gebruik laat zien als in het begin van 2023. Deze daling naar de regio van 107B duidt op een geleidelijk dalende trend van gasverbruik in de afgelopen maand.</p>
<p>Als gevolg daarvan, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De gasvergoedingen van deze week hebben een matige stijging gehad ten opzichte van de vorige week. De lage gasgrenzen lagen tussen 15-145 gwei, de gemiddelde grenzen tussen 15-782 gwei en de hoge grenzen tussen 15-1520 gwei - wat een groot verschil in gasvergoedingen laat zien gedurende de afgelopen week.</p>
<p>In de afgelopen 24 uur waren de top ‘Gas Guzzlers’ volgens Etherscan Blur.io: Marketplace (met totale kosten van $556.149,45,756,45 of 337,35 ETH), 0xD4307E0acD12CF46fD6cf93BC264f5D5D1598792 (met totale kosten van $512.265,46 of 310,73 ETH) en Seaport 1.1 (met totale kosten van $385.899,76 of 234,08 ETH) - wat een opmerkelijke stijging laat zien ten opzichte van de vorige week.</p>
<p>De geschatte kosten van transacties over platforms zoals OpenSea: Sale, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V3: Swap en USDT: Transfer zijn voorgesteld tussen $2.94 en $10.95, volgens Etherscan.</p>
<h2 id="h2-De20huidige20macrosituatie181473"><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-Citigroup20verwacht20minder20harde20landing20voor20de20wereldeconomie20in2020235289"><a name="Citigroup verwacht ‘minder harde’ landing voor de wereldeconomie in 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Citigroup verwacht ‘minder harde’ landing voor de wereldeconomie in 2023</h3><p>Op woensdag begonnen economen van Citigroup hun wereldwijde groeivoorspelling matig te verhogen, waarbij ze hypothezeerden over een ‘minder harde’ landing voor de wereldeconomie. Aan de andere kant geloven economen dat de wereldeconomie zal groeien met het traagste tempo in 40 jaar. De makelaardij heeft voorgesteld dat de wereldwijde groei dit jaar zal vertragen tot ongeveer 2,2%, wat 0,25% hoger is dan hun vorige hypothese.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week807388"><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 gemengd sentiment vertoont, is het waarschijnlijk dat dit zich zal voortzetten in de komende week, maar de onderliggende waarderingskoers voor het merendeel van de activa in de top 100 lijkt te wijzen op een langzame en geleidelijke stijging, wat duidt op een positiever marktsentiment.</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 beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle andere gevallen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>