RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0byBNYXJrdCBoZXJzdGVsdCB6aWNoIG5hIG1lZXJkZXJlIGNyaXNlcyBkaWUgaGViYmVuIGdlbGVpZCB0b3QgZWVuIHZhbiBkZSBsYWFnc3RlIG1vbmRpYWxlIGVjb25vbWlzY2hlIHByb2R1Y3RpZXMgaW4gZGVjZW5uaWE6IEJVU0Qtc3RhYmxlY29pbiB6aWV0IGVlbiB2ZXJsYWdpbmcgdmFuICQ

2023-01-26, 02:52

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen37677"><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<br><strong>Donderdag 26 januari 2023</strong> We hopen dat jullie tot nu toe een positieve week hebben gehad! Het gaat weer een geweldige dag worden, dus laten we er meteen induiken!</p>
<p><strong>Macro</strong>: Vandaag is een wisselend beeld voor het wereldwijde aandelenpodium, waarbij veel markten de neerwaartse trend voortzetten die gisteren in het licht van rapporten is vastgesteld dat de wereldwijde groei van de output naar verwachting zal vertragen tot 1,9% dit jaar, ten opzichte van 3% vorig jaar. Dit toont een van de laagste groeicijfers van de afgelopen decennia volgens WESP, vandaag gelanceerd. Op dezelfde manier wordt verwacht dat het strakke bereik van de dollar zal worden getest door het BBP en de inflatiemetingen van de Fed.</p>
<p><strong>Crypto</strong>: De totale marktkapitalisatie volgens Coinmarketcap is $1.04T, met een stijging van 1.72% in 24 uur. Na twee dagen van bearish marktactiviteit hebben alle top 20 activa tussen 1-8% gewonnen in de afgelopen dag, blijkbaar afkomstig van de algemene bearishheid van de aandelenmarkt. <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> zag aanzienlijke groei, met een stijging van 7.79% die het naar de drempel van $24.57 heeft gebracht. Bovendien brak Cosmos vandaag door met een stijging van 8.96%, waaruit blijkt dat deze twee activa duidelijk het patroon van de bearish trend hebben doorbroken en worden gedreven door bullish sentimenten.</p>
<p><strong>Onderwerp van de dag</strong>: BUSD Stablecoin ziet een vermindering van $ 2 miljard in het licht van wanbeheer</p>
<p><strong>Opmerkelijke koppen</strong>: CNBC’s Jim Cramer dringt er bij beleggers op aan om weg te blijven van crypto; Goldman Sachs rangschikt <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> als ‘s werelds best presterende activum; De ‘echte’ eigenaar van Bithumbs wordt geconfronteerd met een arrestatiebevel wegens verduistering; Robinhood bevestigt de Twitter-hack die een frauduleuze cryptomunt promootte; Een groep slachtoffers van ANKR-exploit beweert dat het bedrijf hen slechts 50% heeft vergoed.</p>
<h2 id="h2-Macro20in20een20oogopslag20Prognose20groei20wereldoutput20vertraagt20Matige20economische20vooruitzichten20kunnen20het20behalen20van20SDG20bedreigen2020Is20de20wereldeconomie20in20gevaar881111"><a name="Macro in een oogopslag: Prognose groei wereldoutput vertraagt; Matige economische vooruitzichten kunnen het behalen van SDG bedreigen - Is de wereldeconomie in gevaar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro in een oogopslag: Prognose groei wereldoutput vertraagt; Matige economische vooruitzichten kunnen het behalen van SDG bedreigen - Is de wereldeconomie in gevaar?</h2><p>Gisteren bracht een somber kantelpunt in de internationale aandelenmarkt, met een overvloed aan rood en verliezen, waarvan deze momentum zich heeft uitgebreid naar vandaag. In de afgelopen 24 uur hebben veel westerse aandelenmarkten een opmerkelijke klap gekregen, verder gedaald in het licht van gegevens die suggereren dat de groei van de wereldproductie naar verwachting zal vertragen van een geschatte 3% in 2022 tot 1,9% - een van de laagste groeicijfers in decennia. Dit nieuws werd vandaag gebracht door de United Nations World Economic Situation and Prospects (WESP 2023) die vandaag is gelanceerd.</p>
<p>Dit sombere rapport heeft een onzekere vooruitzicht geschetst voor het mondiale economische toneel in het komende jaar, met name gezien het feit dat de gegevens hebben aangetoond dat er een dreiging is tegen het bereiken van de 17 Sustainable Development Goals (SDG’s). Secretaris-Generaal van de Verenigde Naties, Antonio Guterres, erkende dit: ‘Dit is niet het moment voor kortetermijndenken of knie-jerk-fiscale bezuinigingen die ongelijkheid verergeren, het lijden vergroten en de SDG’s verder buiten bereik kunnen brengen. Deze ongekende tijden vragen om ongekende actie.’ Iets geruststellends is het feit dat het rapport heeft uiteengezet dat het internationale groeipercentage zou kunnen toenemen tot 2,7% in 2024, naarmate de gevolgen van de recente mondiale crises beginnen te verzachten. Deze prognose is echter sterk afhankelijk van het tempo en de coördinatie van verdere monetaire verkrapping, de gevolgen van de oorlog in Oekraïne en de mogelijkheid van verdere verstoring van de toeleveringsketen.</p>
<p>In vergelijkbaar bearish nieuws hebben analisten opgemerkt dat nabije technische barrières die chartreaders gebruiken om transacties te dicteren, waarschijnlijk niet de volgende trend zullen dicteren vanwege het ontbreken van de duidelijke fundamentele basis in de Amerikaanse aandelenmarkten. Dit ontbreken dient als een getuigenis van het gebrek aan tractie dat is gevestigd in benchmark risk assets, zoals de S&amp;P 500. Analist John Kicklighter heeft ook opgemerkt dat de markt de ‘fundamentele omvang die nodig is’ heeft gemist om de aandelenmarkten uit hun passieve stagnatie te halen. Echter, de publicatie van het Amerikaanse BBP voor het vierde kwartaal staat gepland voor later vandaag, met de Amerikaanse PCE-deflator die morgen plaatsvindt, beide kunnen een natuurlijke update geven over de gezondheid van ‘s werelds grootste economie en inzicht bieden in de toekomst van de rest van de internationale economie.</p>
<p>Met het huidige rapport waarin een sombere toekomst voor de aandelenmarkt wordt beschreven, zou de enige plausibele verlossing kunnen komen van de binnenkort verwachte Amerikaanse gegevenspublicaties voor het einde van deze week. Deze kunnen essentieel inzicht bieden in de gezondheid van de aandelenmarkten en dienen als indicator voor de toekomstige gezondheid van de internationale economie. Als de gegevenspublicaties echter verder bijdragen aan het negatieve sentiment, kunnen de aandelenmarkten gemakkelijk worden geteisterd door meer bearishness en verder afnemend investeerdersvertrouwen.</p>
<p><strong>Markten van vandaag op 24 januari 03:21 GMT+8 💡</strong></p>
<p>BTC +2.14% op $23,065.21; ETH +2.69% op $1,595.71.</p>
<p>Azië: Australië +0,47%; Japan +0,35%; Hong Kong +1,82%; China +0,76%; India -1,25%.</p>
<p>Europa: Londen +0,44%; Parijs -0,09%; Frankfurt -0,08%.</p>
<p>US Spot Indices: Dow +0.029%; S&amp;P -0.018%; Nasdaq -0.18%.</p>
<p>US Index Futures: Dow -0.09%; S&amp;P +0.12%; Nasdaq -0.24%.</p>
<p>Amerikaanse tweejarige schatkist is met -0,01% gedaald naar 4,127%.</p>
<p>De Amerikaanse tienjarige schatkistrendement is met -0,021% gedaald tot 3,441%.</p>
<p>De tienjarige Gilt Bond van het Verenigd Koninkrijk had een verandering van -0,033% en staat op 3,244%.</p>
<p><a href="https://www.gate.io/trade/USD_USDT" target="_blank">Amerikaanse dollar</a> Index -0.31% op 101.60.</p>
<p>FX in 24 uur: GBP: +0.0012%; EUR: +0.0006%; JPY: -0.21%; CNY: +0.0087%.</p>
<p>Goud +0.08% op 1.947,50; Licht ruwe olie +0.39% op 80.46.</p>
<p><strong>Marktkatalysatoren deze week 🧠</strong></p>
<p>Donderdag: BEA schat het BBP voor het vierde kwartaal<br>Vrijdag: BEA publiceert de PCE-prijsindex</p>
<p><strong>Katalysatoren volgende week 🗓</strong></p>
<p>Maandag: JPN Banen/Werkloosheidscijfers<br>Dinsdag: S&amp;P HPI Composite, CB Consumentenconferentie</p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Crypto20Markt20Begint20te20Herstellen20in20Bullish20Gebied2020Keert20de20Bullish20Golf20Terug636764"><a name="Crypto Dagelijkse Samenvatting: Crypto Markt Begint te Herstellen in Bullish Gebied - Keert de Bullish Golf Terug?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Crypto Markt Begint te Herstellen in Bullish Gebied - Keert de Bullish Golf Terug?</h2><p>Na deze week te hebben samengevallen met de neerwaartse trend van de aandelenmarkt, lijkt de cryptocurrency-markt zichzelf te hebben bevrijd van deze kettingen en begon het waarde te regenereren ondanks dit. In de afgelopen 24 uur is de marktkapitalisatie gestegen tot $1,04B, een stijging van 200 miljoen ten opzichte van gisteren, en alle top 20 activa hebben een opmerkelijke stijging gezien van tussen de 1-8%. De plotselinge opkomst van een bullish trend geeft aan dat de bullish golf misschien wel terugkeert met kracht, waardoor de zorgen van investeerders worden verlicht dat dit in feite een bull trap was. Deze mogelijkheid zou echter kunnen blijven bestaan ​​als de cryptomarkt terugvalt in bearishness naarmate de wereldeconomie blijft lijden.</p>
<p>Ondanks deze plotselinge bullishness waarschuwde CNBC’s Jim Cramer investeerders om zich te onthouden van cryptocurrency als geheel, waarbij hij zei dat <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> doet niet dienen als een ‘hedge tegen alles’. Cramer drong er in plaats daarvan bij beleggers op aan om naar goud te kijken als de primaire alternatieve investering, waarbij hij verwees naar de analyses van analist Carley Garner. Cramer voegde eraan toe: ‘je moet nu de crypto-supporters negeren die’ <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> stuitert’. Cramer’s kritiek komt in het licht van een opmerkelijk positieve maand voor <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> waarbij het actief boven zijn viermaanden hoogste punt is gestegen en consistent handelt in het lagere $20k-gebied voor de eerste keer in maanden. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is begonnen te herstellen, evenals een overvloed aan andere activa in de markt.</p>
<p>Bovendien heeft de bankgigant Goldman Sachs in een recent rapport gerangschikt <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> boven goud, het Amerikaanse ministerie van Financiën en de S&amp;P 500, in de lijst van de ‘best presterende activa ter wereld’. Met <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Nadat Goldman Sachs de kroon heeft genomen, rechtvaardigde het deze beslissing door te stellen dat het zijn cryptocurrency-paren en die belangrijke financiële instellingen van de traditionele financiële markt heeft overtroffen met een risico-gecorrigeerd rendement (Sharpe-ratio) van 3,1.</p>
<p>Van de top 20 munten heeft een meerderheid een opmerkelijke stijging in waarde gezien. Cosmos heeft de grootste winst geboekt in de afgelopen 24 uur, met een stijging van 8,8% en een gemiddelde handelsprijs van $13,54. Met vandaag de broodnodige adempauze voor de top 20 van de huidige bearish trend, zou deze plotselinge marktbrede verschuiving kunnen wijzen op een positieve toekomst voor de grafieken gedurende de rest van de week.</p>
<p>Met de cryptocurrency-markt die zich momenteel losmaakt van het spiegelen van de slechte prestaties van de aandelenmarkt, is het mogelijk dat de prestaties van de cryptomarkt blijven verbeteren. Het is echter mogelijk dat de verslechterende wereldeconomie en afnemend investeerdersvertrouwen invloed hebben op de cryptomarkt en de instroom van fondsen vertragen. Uiteindelijk is het van cruciaal belang om de markt de komende dagen nauwlettend in de gaten te houden om te zien of de bullish trend bestand is tegen de tegenspoed van de wereldeconomie.</p>
<p><strong>Top 20 Munten Prestaties 🌐</strong></p>
<p><strong>BTC</strong> +2.14% bij $23,065.21;<br><strong>ETH</strong> +2.69% op $1,595.71.</p>
<p><strong>BNB</strong> +1.96% op $306.91;<br><strong>XRP</strong> +2.45% op $0.4162;<br><strong>DOGE</strong> +2.46% op $0.08633.</p>
<p><strong>ADA</strong> +3.56% op $0.3713;<br><strong>MATIC</strong> +3,81% op $ 0,991;<br><strong>DOT</strong> +3.69% op $6.39.</p>
<p><strong>TRX</strong> +2.79% op $0.06179;<br><strong>SJIB</strong> +3.78% op 0.00001163<br><strong>LTC</strong> +2.63% op $89.20.</p>
<p><strong>SOL</strong> +2.49% op $24.54;<br><strong>UNI</strong> +4.02% op $6.57;<br><strong>AVAX</strong> +4.48% op $17.82.</p>
<p><strong>ATOM</strong> +8.88% bij $13.54;<br><strong>LINK</strong> +3.87% bij $6.93.</p>
<h2 id="h2-Onderwerp20van20de20Dag20BUSD20Stablecoin20Ziet202B20Vermindering20Naar20aanleiding20van20Slecht20Beheer259768"><a name="Onderwerp van de Dag: BUSD Stablecoin Ziet $2B Vermindering Naar aanleiding van Slecht Beheer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de Dag: BUSD Stablecoin Ziet $2B Vermindering Naar aanleiding van Slecht Beheer</h2><p>Cryptocurrency exchange-gigant Binance heeft onlangs verdere dalingen van zijn BUSD-stablecoins gemeld te midden van problemen met het beheer van de exchange’s gekoppelde tokens die eerder deze maand aan het licht kwamen, te midden van andere debacles rond de exchange. De omloop van BUSD daalde gisteren naar $15,4 miljard, nadat het de afgelopen week met $1 miljard en in totaal met $2 miljard in de afgelopen maand was gedaald, volgens CoinGecko. Deze huidige daling heeft de neergang van BUSD vanaf $22 miljard begin december verder verlengd, toen angstige gebruikers zich haastten om geld op te nemen na de publicatie van een mislukt rapport over de reserves van zijn digitale activa.</p>
<p>Eerder deze maand ontdekte het blockchain onderzoeksbureau, ChainArgos, dat de BUSD-token niet altijd volledig werd gedekt door zijn reserves (kasreserves en Amerikaanse schatkistbiljetreserves) gedurende 2020 en 2021. Nadat het probleem was erkend, verklaarde Binance dat het probleem was opgelost. Bloomberg meldde echter onlangs dat de beurs klantenfondsen had vermengd met het onderpand van Binance-peg-tokens. Naast deze recente problemen is BUSD ook achtergebleven bij zijn concurrenten in de hevige stablecoin-competitie, waarbij het 11,3% van zijn marktkapitalisatie in een maand heeft verloren, terwijl USDT 1,3% wint en USDC slechts 1,9% verliest. Ondanks dit blijft BUSD echter een van de weinige stablecoins die vorig jaar zijn marktwaarde heeft vergroot.</p>
<h2 id="h2-BNB20BNB20over20het20hoofd20zien150916"><a name="BNB (BNB) over het hoofd zien" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BNB (BNB) over het hoofd zien</h2><p>BNB (BNB) $308.54 (+4.12) - Neutrale vooruitzichten</p>
<p><strong>Dichtstbijzijnde dagelijkse ondersteuningszone</strong>: 300.21-304.13</p>
<p><strong>Dichtstbijzijnde dagelijkse weerstandszone</strong>: 313.2</p>
<p><strong>Belangrijk niveau: $304,13 (Maandelijkse Hoogtepunt van januari 2023)</strong></p>
<p><img src="https://gimg2.gateimg.com/image/article/1674700737001.png" alt=""><br>Gegevens met dank aan CoinMarketCap</p>
<p><strong>Dagelijkse weerstandszones:</strong></p>
<p>301,74-302,1<br>302,49-304,04<br>304,79-313,2</p>
<p><strong>Dagelijkse ondersteuningszones:</strong></p>
<p>300.46-301.17<br>304.31-306.91<br>308.8-313</p>
<p>Ondanks de huidige dalende prestaties van BUSD heeft <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> recentelijk een sterke stijging in momentum gezien, wat heeft geleid tot een opmerkelijke stijging in waarde. Met een stijging van 3,5% alleen vandaag, wordt BNB nu verhandeld voor een gemiddelde van $308, nadat het de 7-daagse SMA heeft doorbroken en dicht bij zijn maandelijkse hoogtepunt komt door een dagelijkse hoogte van $313,2 te bereiken. Op dit moment presteert BNB vergelijkbaar met zijn bullish golf die in november werd gezien.</p>
<p>Op technisch vlak lijkt het erop dat stieren gisteren de dip naar de 20-daagse EMA ($290) hebben gekocht, zoals te zien is aan de lange staart op de kaars. Dit suggereert dat het BNB/USDT-paar het potentieel heeft om te schommelen tussen de 20-daagse EMA en $318 terwijl de stieren en beren worstelen. Als de prijs door de weerstandszone van $318 kan breken, kan dit het paar richting $360 duwen. Als de asset echter geen momentum kan behouden, kan het gemakkelijk instorten onder de 20-daagse EMA en richting de 50-daagse SMA van $270 duiken.</p>
<h2 id="h2-Verdere20Lezing337585"><a name="Verdere Lezing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verdere Lezing</h2><p><strong><a href="https://www.gate.io/blog_detail/2069/" target="_blank">Gate.io 2023: Focus terug op de fundamentals</a></strong> | Onze oprichter, Lin Han, bespreekt de liefdadigheidsinitiatieven van Gate en doelen voor het nieuwe jaar.</p>
<p><strong> <a href="https://www.gate.io/blog_detail/2066/" target="_blank">Pas op voor NFT-oplichting - Hoe onderscheid te maken tussen echte en valse NFT?</a> </strong>| Er zijn 7 manieren om de waarheid over NFT’s te vertellen om u weg te houden van de NFT-zwendel</p>
<p><strong><a href="https://www.gate.io/blog_detail/2064/" target="_blank">ChatGPT AI heeft invloed op de gezondheidszorg, Stijgende prijzen treffen Amerikanen, De herverdelingsbeleid van China beïnvloedt vastgoedontwikkelaars</a></strong> Zoals we in het verleden hebben gezien, zijn mondiale gebeurtenissen en de cryptowereld vaak met elkaar verweven.</p>
<h2 id="h2-Opmerkelijke20koppen204927"><a name="Opmerkelijke koppen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opmerkelijke koppen</h2><p>🔹 Jim Cramer van CNBC dringt er bij investeerders op aan om weg te blijven van crypto nadat hij dat heeft beweerd <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> is geen bescherming tegen ‘iets’.</p>
<p>🔹 Goldman Sachs rangschikt <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> als ‘s werelds best presterende activum tot nu toe vóór goud, de Amerikaanse schatkist en de S&amp;P 500.</p>
<p>🔹 De ‘echte’ eigenaar van Bithumbs wordt geconfronteerd met een arrestatiebevel wegens verduistering, maar ook wegens schending van vertrouwen en manipulatie.</p>
<p>🔹 Robinhood bevestigt de Twitter-hack die een frauduleuze crypto-token promootte nadat verschillende van zijn social media-accounts waren gehackt voor illegale promotie.</p>
<p>Een groep ANKR-exploitanten beweert dat het bedrijf hen slechts 50% heeft vergoed na te hebben beweerd dat ze worden gediscrimineerd omdat ze liquiditeitsverschaffers zijn voor concurrerende munten.</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 is toegestaan mits Gate.io wordt vermeld. In alle gevallen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>