RGFnZWxpamtzIE5pZXV3cyB8IENyeXB0byBNYXJrdCBiZWdpbnQgdmVyZGVyIHRlIGRhbGVuIG5hYXJtYXRlIGRlIGFhbmRlbGVubWFya3Qgdm9sZ3Q7IFZpdGFsaWsgQnV0ZXJpbiBvbnRodWx0IGRlIGxhYXRzdGUgJ3VpdGRhZ2luZycgdm9vciBFdGhlcmV1bQ==

2023-01-25, 02:33

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-TL20DR356164"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>🥂 Goedemorgen, vandaag is het woensdag 25 januari 2023. We hopen dat jullie een positieve start van de week hebben gehad.<br><strong>Het wordt weer een geweldige dag - laten we er meteen induiken!</strong></p>
<p>Macro: Na krachtig het begin van de week te zijn ingegaan en leek te herstellen, is de aandelenmarkt sindsdien begonnen te dalen, aangezien de bedrijfswinsten en bedrijfsactiviteiten-enquêtes zijn vrijgegeven om de huidige gezondheid van de wereldeconomie aan te geven. Met problemen met betrekking tot de opening van de veiling van de New York Stock Exchange. Desalniettemin lijkt het Aziatische aandel landschap zich sterk te houden en blijft het consistente groei vertonen.</p>
<p>Crypto: De totale marktkapitalisatie volgens Coinmarketcap bedraagt $1,02T, wat in 24 uur met 2,61 is gedaald. Naarmate de marktkapitalisatie is gedaald, zijn ook de meeste van de top twintig activa in de afgelopen 24 uur gedaald, met verliezen tussen 1-5% op de hele markt. Dit is waarschijnlijk het gevolg van de potentiële correctie van de aandelenmarkt in combinatie met een toenemend aantal economische en bedrijfsgerelateerde gegevens die worden vrijgegeven om de gezondheid van de wereldwijde economie aan te geven. <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX) leek echter het meest te lijden in de afgelopen dag, met een totaal verlies van 6,87%, wat neerkomt op $16,15. Activa die een vergelijkbaar volume hebben verloren, zijn onder meer Cosmos (ATOM), Chainlink (LINK) en <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> (UNI).</p>
<p>Onderwerp van de dag: Vitalik Buterin onthult de laatste ‘uitdaging’ voor Ethereum</p>
<p>Opvallende koppen: Cardano-ontwikkelaars pakken het incident aan dat ervoor zorgde dat de nodes van de blockchain dit weekend kort offline gingen; De Britse regering huurt een CBDC-leider in; Nayib Bukele slaat terug naar critici terwijl El Salvador de schuld van $800 miljoen volledig afbetaalt; Lange tijd inactieve ETH-walvis zet 49K ETH vast; Vitalik Buterin stelt een ‘stealth adres’ systeem voor om de privacy van de blockchain te verbeteren.</p>
<h2 id="h2-Macro20in20een20oogopslag20de20enqutes20naar20bedrijfsfinancile20gegevens20zijn20vrijgegeven20en20schetsen20een20somber20beeld20voor20de20wereldeconomie810053"><a name="Macro in een oogopslag: de enquêtes naar bedrijfsfinanciële gegevens zijn vrijgegeven en schetsen een somber beeld voor de wereldeconomie." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro in een oogopslag: de enquêtes naar bedrijfsfinanciële gegevens zijn vrijgegeven en schetsen een somber beeld voor de wereldeconomie.</h2><p>Met de week die begon met een schijnbaar sterke start voor de internationale economie, zijn de rollen de afgelopen 24 uur snel omgedraaid, waarbij een meerderheid van de westerse aandelenmarkten een klap hebben gekregen als gevolg van gegevenspublicaties. De recente opkomst van bedrijfswinsten en zakelijke activiteitenonderzoeken heeft getuigd van de huidige onrust in de mondiale economie, waardoor het vertrouwen van investeerders wankelt. Als gevolg hiervan sloot de benchmark S&amp;P 500 van Wall Street de dag af met -0,10% en gleed de Nasdaq Composite driemaal deze waarde, waardoor deze met -0,30% in een spiraal kwam.</p>
<p>Echter, ondanks deze recente bearish outlook, heeft een analist van JPMorgan verklaard dat er een ‘betere sentiment over de [groei] vooruitzichten’ is, wat leidde tot de hoogste stand van de S&amp;P 500 sinds begin december op maandag van deze week, met technologie- en halfgeleideraandelen die bullish omhoog schoten. Toch is deze positieve outlook snel afgenomen, aangezien de Amerikaanse bank heeft verklaard dat zij niet verwacht dat de huidige januari-beursrally zal doorzetten in de rest van het eerste kwartaal, met de verklaring dat: ‘De recente verzwakking van economische gegevens en een verwachte daling van winstverwachtingen en zwakke [volledig jaar] richtlijnen wijzen op markten die waarschijnlijk lager zullen bewegen.’</p>
<p>Positief voor de westerse aandelenmarkten is dat valutaanalist Lee Hardman van MUFG meldde dat handelaren dit jaar ‘nieuw vertrouwen hebben dat centrale banken hun renteverhogingscycli kunnen pauzeren’, aangezien de bezorgdheid over het vooruitzicht van verdere inflatie en een recessie op internationale schaal is toegenomen. Zijn optimisme komt in het licht van functionarissen van de Amerikaanse Federal Reserve en de Europese Centrale Bank die volhouden dat de strijd tegen de inflatie nog lang niet voorbij is, zoals blijkt uit de bearish gegevens die vandaag zijn vrijgegeven en de bijbehorende klap die de aandelenmarkt heeft gekregen.</p>
<p>Ondanks de huidige onrust op de westerse aandelenmarkten hebben verschillende Aziatische effectenmarkten de afgelopen 24 uur opmerkelijke winsten behaald. De economische heropening van China is positief gecorreleerd met zijn aandelenmarkt, wat heeft geleid tot een stijging van +0,76% in de afgelopen dag, waarbij deze bullish momentum zich uitstrekt tot Hong Kong en India. Als gevolg hiervan leiden deze factoren, samen met de afnemende recessievrees in Europa en de afkoeling van de Amerikaanse inflatie, sommige internationale investeerders in een gevoel van optimisme, ongeacht de meer micro-economische details.</p>
<p>Nu de aandelenmarkt blijft waarde verliezen, is dit een indicatie van de huidige mondiale economie die nog steeds gehinderd wordt door de langdurige effecten van de COVID-19 pandemie, de oplopende gas- en energieprijzen in Europa, en internationale inflatie. Terwijl deze gevolgen blijven weerklinken in de mondiale economische markten, lijkt er weinig teken te zijn dat de aandelenmarkt krachtig zal opkomen en bullisch zal doorgaan, vooral omdat een correctie onvermijdelijk is.</p>
<p><strong>Markten van vandaag op 24 januari 03:21 GMT+8 💡</strong></p>
<p>BTC -1,28% op $22.680,95; ETH -4,67% op $1.553,37.</p>
<p>Azië: Australië -0.42%; Japan -0.02%; Hongkong +1.82%; China +0.76%; India +0.06%.</p>
<p>Europa: Londen -0.28%; Parijs +0.40%; Frankfurt -0.07%.</p>
<p>VS Spot Indices: Dow +0.03%; S&amp;P -1.40%; Nasdaq -0.69%.</p>
<p>US Index Futures: Dow -0.49%; S&amp;P -0.43%; Nasdaq -1.28%.</p>
<p>Amerikaanse schatkist met een looptijd van twee jaar is met -0.001% gedaald naar 4.152%.</p>
<p>Amerikaanse tienjarige schatkistrendement is gedaald met -0.018% tot 3.451%.</p>
<p>De tienjarige Britse Gilt Obligatie had een verandering van -0,083% en staat op 3,277%.</p>
<p><a href="https://www.gate.io/trade/USD_USDT" target="_blank">De Dollar van de V.S.</a> Index 0,00% op 101,92.</p>
<p>FX in 24 uur: GBP: -0.15%; EUR: +0.00045%; JPY: +0.07%; CNY: +0.0087%.</p>
<p>Goud +0,10% op 1.937,50; Licht ruwe +0,14% op 80,24.</p>
<p><strong>Marktkatalysatoren deze week 🧠</strong></p>
<p>Donderdag: BEA geeft schatting van het bbp voor het vierde kwartaal<br>Vrijdag: BEA geeft de PCE-prijsindex uit</p>
<p><strong>Catalyst volgende week 🗓</strong></p>
<p>Maandag: JPN Banen/Werkloosheidscijfers<br>Dinsdag: S&amp;P HPI Composite, CB Consumentenconferentie</p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Crypto20Markt20ondergaat20verdere20terugtrekking20terwijl20de20aandelenmarkt20positief20opent20Is20de20markt20hier20gestagneerd257773"><a name="Crypto Dagelijkse Samenvatting: Crypto Markt ondergaat verdere terugtrekking terwijl de aandelenmarkt positief opent; Is de markt hier gestagneerd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Crypto Markt ondergaat verdere terugtrekking terwijl de aandelenmarkt positief opent; Is de markt hier gestagneerd?</h2><p>Met het wereldwijde economische toneel dat verstoord is door tegenstrijdige bullish en bearish gegevens en sentimenten, wat heeft geleid tot een aanzienlijke daling van de westerse aandelenmarkten, lijkt dit te zijn overgeslagen naar crypto. In de afgelopen 24 uur heeft bijna al het top 20 activa een opmerkelijke klap gekregen, waarbij ze tussen de 1% en 7% hebben verloren. De dramatische daling in de waarde van de cryptocurrency-markten dient als een indicatie dat de bullish golf die we onlangs hebben gezien, mogelijk een vluchtige trend was en geen teken van een opkomende bullmarkt. BTC heeft echter zijn positie boven de $22.000 weten te behouden, met een matige daling van 1,28% in de afgelopen dag en verhandeld tegen een gemiddelde van $22.680. Helaas is <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> met 4,67% gedaald, waardoor het door de prijsvloer van $1.600 is geduwd en terugkeert naar het midden van het bereik van $1.500. Deze verliezen hebben zich over de markt uitgestrekt, waardoor de totale marktkapitalisatie met 2,61% is gedaald naar $1,02 biljoen.</p>
<p>In ander nieuws, hebben Cardano-ontwikkelaars het incident aangepakt dat ervoor zorgde dat de nodes van de blockchain dit weekend kort offline gingen. Gedurende het weekend heeft het Cardano-netwerk een 50% uitval ondervonden op relay- en block-producing nodes, waarvan de oorzaak momenteel onbekend is. De verbreking en herstart van deze nodes zouden zijn ‘veroorzaakt door een voorbijgaande anomalie’ die leidde tot ofwel de verbreking van nodes van een peer of nodes die een uitzondering veroorzaakten en herstartten. Ontwikkelaars benadrukten echter dat het gehele netwerk niet uitviel en dat de meerderheid van de getroffen nodes ‘op gepaste wijze hersteld’ waren.</p>
<p>Bovendien werd ook gemeld dat de Britse regering heeft overwogen om een ​​leider voor de Central Bank Digital Currency (CBDC) aan te nemen om de ‘strategische richting’ van het Britse schatkistbeheer over te nemen, aangezien ze streven naar het creëren en implementeren van een effectieve digitale pond. Dit komt aan het licht nu de Britse regering begint met een verdere aanpak van de regelgeving voor cryptocurrency, omdat de druk toeneemt door de invoering van het MiCA-beleid van de EU, dat in juni van dit jaar zal worden gehandhaafd.</p>
<p>Van de top 20 munten heeft het merendeel verliezen geleden, ondanks de voornamelijk positieve stijging in waarde op wekelijkse basis. Avalanche heeft de grootste verliezen geleden in de afgelopen 24 uur, met een verlies van 6,87% en een gemiddelde handelsprijs van $16,95. Aangezien geen van de top 20 activa enige verlichting heeft gekregen van deze plotselinge golf van bearish sentiment, is het waarschijnlijk dat deze momentum de verwachte uittocht uit de crypto winter zal verstoren.</p>
<p>Met de cryptocurrency-markt die nu opnieuw geleidelijk daalt, net als de westerse aandelenmarkt, is het mogelijk dat de prestaties van laatstgenoemde in de komende dagen in combinatie met wereldwijde economische gegevens een negatieve invloed kunnen hebben op de prestaties van de cryptocurrency-markt. Dit zou geruchten kunnen verdrijven dat de recente bullish golf een indicatie was van het begin van een bullmarkt en in plaats daarvan laten zien dat de crypto-winter nog lang niet voorbij is.</p>
<p><strong>Top 20 Munten Prestaties 🌐</strong></p>
<p>BTC -1.28% op $22.680,95; ETH -4.67% op $1.553,37.<br>BNB -1.23% op $301,91; <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> -4.20% op $0,4052; DOGE -5.28% op $0,08401.<br>ADA -5.56% op $0,3548; MATIC -3.90% op $0,9545; DOT -6.58% op $6,15.<br>TRX -4.66% op $0,06; SHIB -6.74% op 0,00001119 LTC -3.76% op $86,79.<br>SOL -5.41% op $22,90; UNI -6.74% op $6,25; AVAX -6,87% op $16,95.<br>ATOM -5.09% op $12,39; <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> -5,19% op $6,67.</p>
<h2 id="h2-Onderwerp20van20de20dag20Vitalik20Buterin20onthult20de20laatste20uitdaging20voor20Ethereum455801"><a name="Onderwerp van de dag: Vitalik Buterin onthult de laatste ‘uitdaging’ voor Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: Vitalik Buterin onthult de laatste ‘uitdaging’ voor Ethereum</h2><p>Met de aanstaande Shanghai Upgrade en de succesvolle uitvoering van de Merge, lijkt het Ethereum-netwerk een hands-on benadering te hanteren om zijn operationele tekortkomingen aan te pakken als middel om zijn technologie en die van bredere blockchaintechnologie te verbeteren. In een poging om deze missie beter uit te voeren, erkende Vitalik Buterin de groeiende behoefte om een privacyoplossing te creëren, omdat standaard alle informatie die in een openbare blockchain wordt ingevoerd ook openbaar wordt gemaakt. Dit heeft Buterin ertoe aangezet om het concept van ‘stealth-adressen’ voor te stellen, die het potentieel hebben om een laag anonimiteit toe te voegen aan peer-to-peer transacties, NFT-overdrachten en <a href="/price/ethereum-name-service-ens" target="_blank" class="blog_inner_link">Ethereum Name Service</a> (ENS) registraties.</p>
<p>Verder uitweiden over het concept, legde Buterin uit dat een ‘Diffie-Hellman-sleuteluitwisseling’ gekoppeld aan een ‘sleutelverblindingsmechanisme’ moet worden geïmplementeerd om ervoor te zorgen dat de koppeling tussen een stealth-adres en de meta-identiteit van een gebruiker openbaar zichtbaar kan zijn. Dit bevordert in wezen nog steeds gedecentraliseerde transparantie, terwijl ook wordt gegarandeerd dat transactie- en gebruikersinformatie privé en veilig kan blijven. Buterin erkende echter ook de ‘langere termijn bruikbaarheidszorgen’, waaronder problemen met sociale herstel, maar blijft ervan overtuigd dat deze problemen in de loop van de tijd kunnen worden opgelost.</p>
<p>Ethereum (ETH) $1,538.32 (-4.67%) - Neutrale Outlook</p>
<h2 id="h2-Ethereum20ETH20Overzicht434466"><a name="Ethereum (ETH) Overzicht:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH) Overzicht:</h2><p><strong>Dichtstbijzijnde dagelijkse steungebied: </strong>1.562,75-1.630</p>
<p><strong>Dichtstbijzijnde dagelijkse weerstandszone:</strong> 1.611,75-1.595</p>
<p><strong>
</strong>Key niveau: $0.4304 (Maandelijks Hoog Van Januari 2023)**</p>
<p><strong>Dagelijkse weerstandszones:</strong></p>
<p>1,553.84-1,566.03<br>1,611.75-1,595<br>1,629.71-1636.4</p>
<p><strong>Dagelijkse ondersteuningszones:</strong></p>
<p>1.633-1.639<br>1.611,21-1.622,92<br>1.549-1.556,75</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674613770unnamed0125.png" alt=""><br>Gegevens met dank aan CoinMarketCap</p>
<p>Vandaag heeft ETH een opvallende bearish wending genomen, die naar beneden trendt in de komende dag. ETH begon de dag met een gemiddelde van $1.637, handelde horizontaal voordat het onder zijn 7-daagse SMA zakte en ten prooi viel aan volatiliteit, waardoor het in een spiraal terechtkwam die het onder de $1.600-zone dwong waar stieren probeerden voorbij te duwen, en terug naar de bovenste regionen van de $1.500-zone.</p>
<p>Echter, hoewel deze plotselinge neerwaartse trend incongruent is met de prestaties van Ethereum in de afgelopen dagen, blijft Ethereum nog steeds boven de prijsgrens waarop het vorige week op dit moment handelde toen de bullish golf de markt volledig in zijn greep had. Dit suggereert dat ondanks de huidige neerwaartse momentum Ethereum nog steeds in veelbelovend prijsterrein kan zijn, vooral wanneer deze gegevens worden vergeleken met de opwaartse prijstrajectorie die het de afgelopen maand heeft laten zien. Over het algemeen kan deze huidige daling duiden op een kleine prijscorrectie voor het activum.</p>
<p>Het kan worden vastgesteld dat met de toenemende persaandacht voor Ethereum en de aanstaande Shanghai Upgrade het vermogen mogelijk blijft profiteren van een positieve prijsstijging en dat het zijn maandelijkse positieve waardestijging kan voortzetten zonder vatbaar te zijn voor bearish marktomstandigheden.</p>
<h2 id="h2-Verder20lezen371071"><a name="Verder lezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verder lezen</h2><p><strong>Gate.io 2023: Focus Terug op de Fundamenten</strong> Onze oprichter, Lin Han, bespreekt de liefdadigheidsinitiatieven van Gate en de doelen voor het nieuwe jaar.</p>
<p><strong>Pas op voor NFT-oplichting - Hoe echt en vals NFT te onderscheiden?</strong> | Er zijn 7 manieren om de waarheid over NFT’s te vertellen om je weg te houden van de NFT-zwendel</p>
<p><strong>ChatGPT AI heeft gevolgen voor de gezondheidszorg, stijgende prijzen treffen Amerikanen, China’s herverdelingsbeleid heeft gevolgen voor projectontwikkelaars</strong> Zoals we in het verleden hebben gezien, zijn mondiale gebeurtenissen en de cryptowereld vaak met elkaar verweven.</p>
<h2 id="h2-Opmerkelijke20koppen700645"><a name="Opmerkelijke koppen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opmerkelijke koppen</h2><p>🔹<br><strong>Ontwikkelaars van <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> hebben gereageerd op het incident dat ervoor zorgde dat de nodes van de blockchain dit weekend kort offline gingen.</strong></p>
<p>🔹<br><strong>De Britse regering zoekt een leider voor CBDC</strong> voor hun treasury-team om de ‘strategische richting’ voor de toekomstige digitale pond te bepalen.</p>
<p>🔹<br><strong>Nayib Bukele slaat terug naar critici terwijl El Salvador $800 miljoen schuld aflost</strong> in zijn geheel nadat er meldingen waren verschenen over zijn wanbetalingen.</p>
<p>🔹 <strong>Lang slapende ETH-walvis stelt 49K ETH </strong>op de markt, wat analisten hoopvol maakt dat een toename van deelname aan ETH-staking kan leiden tot <a href="https://www.gate.io/trade/ETH_USDT" target="_blank">ETH prijs</a> rally.</p>
<p>🔹<strong>Vitalik Buterin stelt een ‘stealth adres’ systeem voor </strong> om de privacy van blockchain te verbeteren als een manier om dezelfde privacy-eigenschappen te bieden als het genereren van een nieuw adres.</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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 glen zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>