RGUgYmVsYW5ncmlqa3N0ZSBkaW5nZW4gZGllIHUgZGV6ZSB3ZWVrIG92ZXIgZGUgY3J5cHRvbWFya3QgbW9ldCB3ZXRlbg==

2023-01-30, 06:35

<p><img src="https://gimg2.gateimg.com/image/article/16750600735大热点资讯.jpeg" alt=""></p>
<h2 id="h2-TL20DR506771"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>In januari is de cryptomarkt gestegen in prijs, volume en media-interesse, waarbij de meeste top 100 substantiële winsten hebben geboekt in de afgelopen maand en nieuwsberichten opduiken over adoptie, innovatie en wetgeving elke dag. Deze nieuwsberichten zijn echter afwisselend bullish, bearish en neutraal, wat wijst op een onzekere toekomst voor de markt op microschaal en de nieuwslandschap heeft verzadigd. Om het deze week gemakkelijker voor u te maken om de markt te navigeren, zijn we hier om de belangrijkste bullish, bearish en vooral impactvolle nieuwsberichten van deze week te bespreken om u te helpen de marktactiviteit van deze week en die van de komende week te begrijpen.</p>
<h2 id="h2-SHIB20gerangschikt20als20de20meest20populaire20starter20crypto464845"><a name="SHIB gerangschikt als de meest populaire starter crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SHIB gerangschikt als de meest populaire starter crypto</h2><p><img src="https://gimg2.gateimg.com/image/article/16750601858311675060116_.pic_hd.jpg" alt=""><br>Shiba Inu Concept Art (Afbeelding met dank aan AnalyticsInsight )</p>
<p>Afgelopen week heeft SHIB een scherpe stijging gezien in interesse van ETH-walvissen, die in een periode van vier dagen meer dan $200 miljoen van het activum hebben verzameld, evenals nieuwkomers in de ruimte, die hun portefeuilles zijn begonnen met het activum. On-chain data ontdekt door Nansen heeft onthuld dat er in de afgelopen zeven dagen meer dan $56 miljoen aan SHIB-tokens naar meer dan 12.000 wallets is gestroomd, waardoor het de meest voorkomende crypto is, naast stablecoins, die in deze balansen in deze periode verschijnt.</p>
<h2 id="h2-Vertrouwen20van20particuliere20beleggers20vernieuwd20nu20inflatiedreiging20wordt20geminimaliseerd140631"><a name="Vertrouwen van particuliere beleggers vernieuwd nu inflatiedreiging wordt geminimaliseerd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vertrouwen van particuliere beleggers vernieuwd nu inflatiedreiging wordt geminimaliseerd</h2><p>Recente macro-economische factoren en de cryptowinter hebben ongetwijfeld het vertrouwen van beleggers in de markt gebroken, wat heeft geleid tot prijs- en volumeafnames op de markt als geheel. Echter, een recente studie door eToro heeft gemeld dat 69% van de particuliere beleggers onaangedaan zijn door de huidige cryptowinter en dat het vertrouwen in de marktruimte wordt hersteld doordat de dreiging van inflatie wordt geminimaliseerd. In Q3 van 2022 werd gemeld dat 24% van de particuliere beleggers zich bedreigd voelde door het risico van inflatie, wat is gedaald naar 11% aan het einde van Q4 2022.</p>
<h2 id="h2-Bedrijf20achter20XLM20gekozen20voor20positie20in20nieuwe20adviescommissie20van20CFTC702950"><a name="Bedrijf achter XLM gekozen voor positie in nieuwe adviescommissie van CFTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bedrijf achter XLM gekozen voor positie in nieuwe adviescommissie van CFTC</h2><p><img src="https://gimg2.gateimg.com/image/article/16750602948321675060129_.pic.jpg" alt=""><br>Stellar-logo (Afbeelding met dank aan ZipMex)</p>
<p>Het team achter de belangrijkste concurrent van XRP, Stella (XLM), is bevestigd om de digitale activabranche te vertegenwoordigen in het onlangs aangekondigde Global Market Advisory Committee (GMAC) van de Commodity Futures Trading Commission (CFTC). Als een van de vier genomineerde crypto-gerelateerde bedrijven die de digitale activabranche vertegenwoordigen, is <a href="/price/stellar-xlm" target="_blank" class="blog_inner_link">Stellar</a> het enige bedrijf dat een hele blockchain vertegenwoordigt. Als gevolg hiervan hebben vertegenwoordigers van Stellar verklaard dat ze hopen ‘een uniek perspectief van layer-1 protocollen aan de tafel te brengen’.</p>
<p>Daarnaast heeft Stellar ook opgemerkt dat ze niet van plan zijn om traditionele financiën te ‘vervangen’ en in plaats daarvan ernaar streven om samen te werken met de industrie en voort te bouwen op reeds gevestigde systemen om een interoperabele en naadloze financiële toekomst te creëren. Een vertegenwoordiger verklaarde: ‘Dit orgaan zal dienen als een uitstekende gelegenheid voor conventionele financiën en blockchain om de huidige en toekomstige vooruitzichten voor integratie te vinden om de integriteit en het concurrentievermogen van de Amerikaanse markten te waarborgen.’</p>
<h2 id="h2-XRP20wint20aan20kracht20naarmate20het20vonnis20van20Ripple20VS20SEC20nadert86361"><a name="XRP wint aan kracht naarmate het vonnis van Ripple VS SEC nadert" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XRP wint aan kracht naarmate het vonnis van Ripple VS SEC nadert</h2><p><img src="https://gimg2.gateimg.com/image/article/16750603498331675060141_.pic.jpg" alt=""><br>Ripple concept art (afbeelding met dank aan Financial Times)</p>
<p>Na de bekendmaking van een mogelijke datum voor de afhandeling van een rechtszaak heeft de inheemse cryptocurrency <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> van Ripple een marktkapitalisatie van meer dan $20 miljard bereikt, nadat het sinds het begin van januari met 18% is gestegen. Op dit moment wordt XRP verhandeld tegen $0,4106 en lijkt het te midden van een rally te zijn na de optimistische kijk van Ripple Labs CEO Brad Garlinghouse op de afhandeling van de rechtszaak en de feiten die Ripple op tafel brengt.</p>
<p>Naar aanleiding van het optimisme van Garlinghouse heeft XRP de belangrijke weerstandszone van $0.39 doorbroken, waaruit een nieuwe weerstandszone van $0.4076 is ontstaan. Bovendien suggereren zowel de Relative Strength Index (RSI) als de Awesome Oscillator (AO) dat de stieren momenteel de controle hebben over de prijs van het activum. De On Balance Volume (OBV) heeft echter aangegeven dat er weerstand is, wat betekent dat een beweging voorbij het huidige niveau zou kunnen leiden tot een rally voor XRP. Deze bullishness zal naar verwachting de komende weken toenemen naarmate het vonnis dichterbij komt.</p>
<h2 id="h2-Metaverseproject20OrbCity20schiet20meer20dan2010020omhoog20na20polygoonmigratie49614"><a name="Metaverse-project OrbCity schiet meer dan 100% omhoog na polygoonmigratie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Metaverse-project OrbCity schiet meer dan 100% omhoog na polygoonmigratie</h2><p><img src="https://gimg2.gateimg.com/image/article/16750603808341675060153_.pic.jpg" alt=""><br>OrbCity Art (Afbeelding met dank aan OrbCity)</p>
<p>Met een opleving van interesse in de metaverse die de markt verovert nu de stierenmarkt aanhoudt, hebben verschillende metaverse-projecten, waaronder <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> en The Sandbox, een stijging in waarde en volume gezien. Echter, de gedecentraliseerde virtuele wereld, OrbCity, heeft een waardestijging van meer dan 100% doorgemaakt nadat het met succes gemigreerd is naar het Polygon-netwerk.</p>
<p>OrbCity is een virtuele wereld die gebruikers in staat stelt om hun eigen steden te verkennen en te beheren met behulp van native tokens en NFT’s. Verschillende van deze buurten (gebaseerd op echte regio’s) zijn te koop op de NFT-marktplaats Opensea. Op het moment van schrijven werd een OrbCity buurt in San Francisco naar verluidt verkocht voor 15 ETH.</p>
<h2 id="h2-Ontwikkelaars20in20de20cryptoruimte20nemen20toe284965"><a name="Ontwikkelaars in de crypto-ruimte nemen toe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ontwikkelaars in de crypto-ruimte nemen toe</h2><p>Met de recente marktcrash die heeft geleid tot de ontbinding van veel crypto-projecten op verschillende blockchains, lijkt het overschot aan talent toe te nemen naarmate meer ontwikkelaars zich haasten naar een reeks blockchains om verder te innoveren en erop voort te bouwen. <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> kreeg een stijging van 83%, een toename van 10x ten opzichte van 2018, waarvan het Solana-team heeft opgemerkt dat dit hen verder brengt dan welke andere blockchain dan ook op dit gebied.</p>
<p>Andere blockchains die een dergelijke aanzienlijke groei hebben gezien, waren Polygon, Cosmos en Polkadot, waarbij ze respectievelijk een stijging van ontwikkelaars zagen van 40%, 25% en 2%.</p>
<p><a href="https://www.gate.io/activities/crypto-news-carnival#/ &quot;![](https://gimg2.gateimg.com/blog/166564757654240488320221013-155245.png" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/blog/166564757654240488320221013-155245.png" alt=""></a>”</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Matthew Webster-Dowsing</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<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 gevallen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>