RGFnZWxpamtzIE5pZXV3cyB8IENyeXB0byBNYXJrdCBCZXJlbiBEZSBMYXN0IFZhbiBXZXJlbGR3aWpkZSBFY29ub21pc2NoZSBQcmVzdGF0aWUgVmVyaG9naW5nLCBUaGUgU2FuZGJveCBTb2FycyBJbiBWb2x1bWU=

2023-01-23, 01:39

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen53848"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>🥂 Goedemorgen, vandaag is het maandag 23 januari 2023. We hopen dat jullie een rustig weekend hebben gehad! Het wordt weer een geweldige dag, dus laten we ervan genieten!</p>
<p>Macro: De euro is begonnen terug te stuiteren sinds het onder de pariteit met de <a href="https://www.gate.io/trade/USD_USDT" target="_blank">Amerikaanse dollar</a> begin Q4 2022 is het gegroeid met meer dan 13% sindsdien. Europese aardgasprijzen zijn begonnen te dalen als gevolg van warmer weer, waardoor zorgen over een diepe, continentale recessie in 2023 worden verlicht. Aan de andere kant van de oever is door voorspellers gemeld dat de Amerikaanse economie naar verwachting zal dalen in Q2 en Q3, ondanks dat de kans op een recessie in het komende jaar op 65% staat.</p>
<p>Crypto: De totale marktkapitalisatie volgens Coinmarketcap bedraagt $1.05T, wat in 24 uur met 0.5% is gedaald. In het licht van het verbeteren van het mondiale economische podium hebben de meeste van de top 20 activa deze week winsten gezien tot wel 10%, maar velen hebben de afgelopen 24 uur kleine verliezen geleden. Dit is waarschijnlijk te wijten aan zorgen dat inflatie een cruciale rol zal blijven spelen gedurende Q1 van 2023. Het is belangrijk om de verbeterende macro-situatie nauwlettend in de gaten te houden om te zien of dit negatief correleert met de cryptomarkt en de bullish momentum afzwakt dat de afgelopen weken is waargenomen.</p>
<p>Onderwerp van de dag: <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> meldt recordverkoop van land naarmate de populariteit toeneemt</p>
<p>Opmerkelijke koppen: Walvissen hebben ‘s nachts 2,5 biljoen <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> (SHIB) gegrepen; Ripple’s <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> wint aan kracht naarmate het vonnis van de SEC nadert; de minister van de VAE verklaart dat crypto een ‘belangrijke rol zal spelen voor de handel van de VAE in de toekomst’; de Amerikaanse werkgelegenheidsgraad blijft sterk en de inflatie neemt af ondanks recessiezorgen.</p>
<h2 id="h2-Macro20in20n20oogopslag20globale20markten20worden20verwacht20een20positieve20start20van20de20week20te20hebben20Is20het20veilig20om20weer20te20beginnen20met20kopen350263"><a name="Macro in één oogopslag: globale markten worden verwacht een positieve start van de week te hebben; Is het veilig om weer te beginnen met kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro in één oogopslag: globale markten worden verwacht een positieve start van de week te hebben; Is het veilig om weer te beginnen met kopen?</h2><p>Ondanks dat de bredere aandelenmarkt een verbeterde prestatie heeft laten zien gedurende het weekend, wordt de Amerikaanse aandelenmarkt momenteel omgeven door gemengde investeerderssentimenten nu de sterke prestatie begint te vertragen. Dit heeft de vraag opgeworpen wanneer het weer veilig zal zijn om te beginnen met kopen?</p>
<p>Analisten hebben opgemerkt dat de vertraging van de inflatie de Federal Reserve in staat zou kunnen stellen de agressieve cyclus van renteverhogingen te versoepelen. De dreiging van een recessie en verdere inflatie in de VS is echter nog lang niet verdwenen, aangezien het Amerikaanse ministerie van Financiën buitengewone maatregelen heeft genomen om aan de verplichtingen van het land te voldoen nadat de door het Congres besloten schuldlimiet was bereikt, waarbij minister van Financiën Janet Yellen gelooft dat de maatregelen een Amerikaans faillissement tot juni zullen vertragen.</p>
<p>Met de recente verkoopgolf op Wall Street worden de Amerikaanse markten momenteel gekenmerkt door een gemengd beeld op de aandelenmarkt, waarbij de S&amp;P en Nasdaq tussen de 1-2,8% winst hebben geboekt tot vrijdag, terwijl andere aandelen aanzienlijke stijgingen hebben laten zien. Desalniettemin sloten de meeste belangrijke indexen de week lager af, wat erop wijst dat de angst voor een recessie zich heeft vertaald naar een bearish sentiment op de markten.</p>
<p>Op vrijdag werd gemeld dat de Aziatische aandelenmarkt geleidelijk omhoog was getrokken, waarbij China, Japan en Australië allemaal op de hoogte waren van een opwaartse trend in het licht van stijgende winstverwachtingen en initiatieven om het economisch vooruitzicht van China op regionaal niveau te stimuleren. Grotendeels is Azië onaangetast gebleven door de gemengde sentimenten uit de VS. Afwijkend van deze trend was echter India, waar de aandelenmarkt van Mumbai matige verliezen rapporteerde te midden van volatiliteit.</p>
<p>In het VK is de inflatie gedaald tot 10,5%, van een hoogtepunt van 11,10% in oktober. Ondanks deze dip doemt de huidige inflatie op in de buurt van het hoogste punt in 40 jaar en stijgen de prijzen nog steeds. De inflatie in het VK en een groot deel van Europa wordt toegeschreven aan de gevolgen van de pandemie, het conflict tussen Oekraïne en Rusland en de stijgende Europese gas- en energieprijzen. Dit portret van inflatie strekt zich momenteel uit over een groot deel van Europa.</p>
<p><strong>Markten van vandaag op 23 januari 03:21 GMT+8 💡</strong><br>BTC daalt met 1,75% naar $22.819,87; Ether daalt met 1,10% naar $1.644,41<br>Azië: Australië +0,23%; Japan +0,56%; Hong Kong +1,82%; China +0,76%; India -0,44%<br>Europa: Londen +0,08%; Parijs +0,40%; Frankfurt +0,76%<br>US Spot Indices: Dow +1,48%; S&amp;P +1,24%; Nasdaq +2,86%<br>US Index Futures: Dow +0,27%; S&amp;P +1,05%; Nasdaq +2,82%<br>US Two-year Treasury is gestegen met +0,059% naar 4,09%<br>US Ten-year Treasury is gestegen met +0,083 naar 3,4840%<br>UK Ten-year Gilt Bond had geen verandering en staat op 3,378%<br><a href="https://www.gate.io/trade/USD_USDT" target="_blank">Amerikaanse dollar</a> Index -0,07% op 101,99<br>FX in 24 uur: GBP: +0,12%; EUR: +0,47%; Japanse Yen: -0,90%; CNY: 0,00%<br>Goud +1,11% op 1.925; Lichte ruwe olie +0,11% op 81,40</p>
<p><strong>Marktkatalysatoren deze week 🧠</strong><br>Dinsdag: S&amp;P Global Composite PMI voor januari<br>Donderdag: BEA geeft schatting van het BBP voor Q4<br>Vrijdag: BEA geeft de PCE Prijsindex uit</p>
<p><strong>Katalysatoren volgende week 🗓</strong><br>Maandag: JPN Banen/Werkloosheidscijfers<br>Dinsdag: S&amp;P HPI Composiet, CB Consumentenconferentie</p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Crypto20Markt20Ervaart20Kleine20Terugval20Terwijl20Wereldwijde20Markten20Een20Positieve20Opening20Verwachten2020Is20De20Bull20Rally20Een20Bullenval338976"><a name="Crypto Dagelijks Overzicht: Crypto Markt Ervaart Kleine Terugval Terwijl Wereldwijde Markten Een Positieve Opening Verwachten - Is De Bull Rally Een Bullenval?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Crypto Markt Ervaart Kleine Terugval Terwijl Wereldwijde Markten Een Positieve Opening Verwachten - Is De Bull Rally Een Bullenval?</h2><p>Met de internationale economische markten die gehuld waren in gemengde sentimenten, heeft een meerderheid van de crypto-markt verliezen geleden in de afgelopen 24 uur. Met een kleine daling van -2,75% blijft BTC stabiel boven de $22k-drempel op $22.577,19. ETH heeft vergelijkbare verliezen geleden van -2,22% en staat boven de $1.600-drempel op $1.623,24. De totale crypto-marktkapitalisatie volgens gegevens verstrekt door Coinmarketcap blijft sterk op $1,05T, met een daling van -1,6% in de afgelopen dag, wat impliceert dat de huidige bullish golf aan het afzwakken is in het licht van macroveranderingen.</p>
<p>In ander nieuws heeft <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> een 83% toename gezien in het totale aantal ontwikkelaars, volgens een rapport van Electric Capital, wat aangeeft dat ondanks de verwoestende crash in het vierde kwartaal van 2023, het sentiment rond het Solana-netwerk bullish blijft omdat de ontwikkeling nog niet is vertraagd. Op soortgelijke wijze heeft <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> een stijging van 40% in ontwikkelaars gezien, Cosmos zag een toename van 25% en <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> zag een stijging van 2%.</p>
<p>Bovendien, een solo <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> miner heeft gemeld dat ze een blok hebben opgelost met een hash-snelheid van slechts 10 TH/s, waardoor blok 772.793 aan het netwerk is toegevoegd. Op het moment dat het blok werd toegevoegd, was de totale hash-snelheid van BTC iets meer dan 269 exahash per seconde, wat betekent dat de 10 TH/S van de miner slechts 0,000000037% van de volledige rekenkracht van de blockchain vertegenwoordigde. De miner versloeg onwaarschijnlijke kansen en ontving 98% van de in totaal 6,35939231 BTC die was toegewezen voor de blokbeloning en vergoedingen, terwijl de resterende 2% naar Solo CK Protocol ging, een online mining-service die individuele mining mogelijk maakt.</p>
<p>Onder de top 20 munten heeft het merendeel verliezen geleden, ondanks de overwegende stijging in waarde op wekelijkse basis. Solana heeft de grootste verliezen geleden in de afgelopen 24 uur, met een daling van 6,17% en een totaal van $24,02. Echter, het was UNI dat tegen alle verwachtingen in ging en met +1,79% steeg naar $6,89, terwijl de rest van de top twintig moeite had om hun verliezen te herstellen.</p>
<p>Met analisten die een onmiddellijke correctie van het handelsvolume van de traditionele aandelenmarkten voorspellen, die meer dan 100 keer het handelsvolume van cryptocurrencies hebben, wordt verwacht dat dit invloed kan hebben op de crypto-markt in het algemeen. Het is van cruciaal belang om de markt te volgen en te zien of de huidige prijsdalingen aangeven dat de huidige bullgolf een valstrik is, aangezien de correctie nadert.</p>
<p><strong>Prestaties van de top 20 munten 🌐</strong><br>BTC -2,75% op $ 22.577,19; ETH -2,22% op $ 1.623,24.<br>BNB -0,85% op $ 301,71; XRP -2,64% op $0,4014; DOGE +0,68% op $0,088.<br>ADA +1,61% op $ 0,3808; MATIC -1,93% op $ 0,9937; DOT -3,47% op $ 6,19.<br>TRX -0,94% op $ 0,06171; SHIB -1,32% op 0,00001204 LTC -2,62% op $ 87,69.<br>SOL -6,17% op $ 24,02; UNI +1,79% op $ 6,89; AVAX +0,64% op $17,45.<br>ATOM -0,81% op $ 13,30; <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> -0,53% op $ 6,96.</p>
<h2 id="h2-Onderwerp20van20de20Dag20The20Sandbox20meldt20recordverkopen20van20land20doordat20de20populariteit20toeneemt337855"><a name="Onderwerp van de Dag: The Sandbox meldt recordverkopen van land doordat de populariteit toeneemt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de Dag: The Sandbox meldt recordverkopen van land doordat de populariteit toeneemt</h2><p>The Sandbox heeft recordhoogtes van grondverkopen gemeld, waardoor het zich heeft weten te vestigen in de lijst van de meest gebruikte slimme contracten onder de top 100 Ethereum-walvissen in de afgelopen 24 uur. WhaleStats hebben bevestigd dat The Sandbox extra aandacht heeft gekregen van walvissen, wat aangeeft dat de metaverse wereld een stroom van waarde en een toestroom van vraag naar zijn virtuele grondstukken ervaart.</p>
<p>Als een bewijs van zijn groei in de afgelopen maanden heeft het team van The Sandbox gemeld dat de verkoop van zijn onroerendgoed-NFT’s een aanzienlijke groei heeft doorgemaakt van 180% op jaarbasis, met ongeveer $1,4 miljard aan verkopen in deze periode, waardoor de marktkapitalisatie van het land van The Sandbox is gestegen tot $167 miljoen. Hierdoor staat The Sandbox op de derde plaats als metaverse-provider, achter <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> en Otherside.</p>
<p>Aangezien het merendeel van deze handelsactiviteit plaatsvindt in de loop van de bearmarkt, is deze toename van de NFT-verkoop er niet in geslaagd om te correleren met de marktkapitalisatie. In de afgelopen zes maanden is de marktkapitalisatie van SAND in lijn met andere activa gedaald als gevolg van de bearish marktomstandigheden. Nu de bullish golf de markt begint over te nemen, begint SAND echter wat waarde terug te winnen in een gezonde herstelperiode van drie weken.</p>
<h2 id="h2-Overzicht20van20Sandbox20SAND461926"><a name="Overzicht van Sandbox (SAND)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht van Sandbox (SAND)</h2><p><strong>The Sandbox (SAND) $0.8253 (+2.95%) - Neutrale Outlook</strong></p>
<p><strong>Dichtstbijzijnde dagelijkse ondersteuningszone: 0.7974-0.8091</strong><br><strong>Dichtstbijzijnde dagelijkse weerstandszonde: 0.8376-0.8455</strong><br><strong>Belangrijkste niveau: $0.8455 (Maandelijkse hoogte van januari 2023)</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/16744375988121674437553_.pic.jpg" alt=""><br>Gegevens met dank aan TradingView</p>
<p>Op dit moment staat SAND veelbelovend 118% hoger dan zijn dieptepunt van 12 maanden en begint het zijn 200-daags MA te benaderen, maar het betreedt op een willekeurige manier overgekocht gebied, wat betekent dat dit een omgekeerd effect op zijn waarde zou kunnen hebben en het zou kunnen voorkomen dat het het MA aanraakt.</p>
<p>Op een vergelijkend bearish noot is opgemerkt dat de accumulatie van topadressen van SAND in het vroege deel van januari sterk is gestegen. Echter, deze volume is scherp gedaald sinds 19 januari, waarschijnlijk omdat walvissen en topadressen beginnen uit te cashen na de recente bullish rally. Voorafgaand hieraan is de gemiddelde muntleeftijd gekeerd, wat betekent dat SAND regelmatig van eigenaar wisselde, maar er waren geen significante verkopen die een aanzienlijke terugval konden veroorzaken.</p>
<p>Het is mogelijk dat SAND nog langer kan blijven stijgen, vooral als de metaverse-wereld blijft groeien en aandacht blijft trekken van degenen die opnieuw naar de metaverse kijken nu de markt weer op gang komt. Echter, met SAND die gevaarlijk in het overgekochte bereik waggelt, kan dit een waardedaling veroorzaken.</p>
<p>SAND Dagelijkse Weerstandszones:<br>0.7895-0.8012<br>0.804-0.8069<br>0.8376-0.8455</p>
<p>SAND Dagelijkse ondersteuningszones:<br>0.782-0.7878<br>0.8-0.804<br>0.8202-0.8315</p>
<h2 id="h2-Verdere20lezing704746"><a name="Verdere lezing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verdere lezing</h2><p><a href="https://www.gate.io/blog_detail/2069/gateio-2023-focus-back-on-the-fundamentals" target="_blank">Gate.io 2023: Focus terug op de Fundamentals</a> | Onze oprichter, Lin Han, bespreekt Gate’s liefdadigheidsinitiatieven en doelen voor het nieuwe jaar.</p>
<p><a href="https://www.gate.io/blog_detail/2066/distinguish-nft-scams" target="_blank">Let op voor NFT-oplichting - Hoe onderscheid te maken tussen echte en valse NFT’s?</a> Er zijn 7 manieren om de waarheid over NFT’s te vertellen om u weg te houden van de NFT-zwendel</p>
<p><a href="https://www.gate.io/blog_detail/2064/chatgpt-ai-impacts-healthcare-rising-prices-hit-americans-chinas-redistributive-policies-affect-property-developers" target="_blank">ChatGPT AI heeft invloed op de gezondheidszorg, stijgende prijzen treffen Amerikanen, de herverdelingsbeleid van China beïnvloedt vastgoedontwikkelaars</a> Zoals we in het verleden hebben gezien, zijn wereldgebeurtenissen en de cryptowereld vaak met elkaar verweven.</p>
<h2 id="h2-Opmerkelijke20koppen858183"><a name="Opmerkelijke koppen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opmerkelijke koppen</h2><p>🔹 Het <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> uitleenprotocol, Mars, zal op 31 januari zijn mainnet lanceren op de Cosmos blockchain, samen met de uitgifte van MARS-tokens aan gebruikers die het tijdens de twee snapshots op Terra Classic vasthouden.</p>
<p>🔹 FlintWallet voegt ondersteuning toe voor Milkomeda en streeft ernaar om een volwaardige Cardano-gebaseerde portemonnee te worden die compatibel is met elk blockchainnetwerk.</p>
<p>🔹 <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> walvissen verzamelen in minder dan een week $422.000.000 aan SHIBA, waardoor ze hun bezittingen in deze periode met 151% vergroten. SHIBA is nu het meest aangehouden digitale activum door de top 1.000 ETH walvissen.</p>
<p>🔹 De minister van de VAE zegt dat crypto in de toekomst een ‘belangrijke rol zal spelen voor de handel van de VAE’. Dit werd gevolgd door de verklaring van de minister dat ‘wereldwijd bestuur’ het belangrijkste is vooruitgaand.</p>
<p>🔹Het aantal ontwikkelaars van Solana is de afgelopen maanden met 83% gestegen, wat aangeeft dat de ontwikkeling van het netwerk gaande is, ondanks de recente crash.</p>
<p>🔹Dogecoin vermindert CO2-uitstoot met 25%, waardoor het de op twee na snelste crypto is in het verminderen van de ecologische voetafdruk.</p>
<p>🔹 Uit het rapport blijkt dat meerdere Ethereum layer-2-netwerken groeien, waarbij Polygon voorop loopt en een toename van de dagelijkse gebruikersactiviteit van 30% heeft opgeleverd.</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 W-D</strong>, Gate.io onderzoeker<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 op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>