RGFnZWxpamtzIG5pZXV3cyB8ICMgQW1lcmlrYWFuc2Ugc2NodWxkcGxhZm9uZCB2ZXJvb3J6YWFrdCBvbnpla2VyaGVpZCwgYmVsZWdnZXJzIHdhY2h0ZW4gb3AgRk9NQzsgQ3J5cHRvIHZlZXJrcmFjaHRpZyB0ZXJ3aWpsIEJUQyBzdGFnbmVlcnQsIEhLIHJpY2h0IHppY2ggb3AgZGlnaXRhYWwgYWN0aXZhaHVi

2023-05-24, 01:27

<p><img src="https://gimg2.gateimg.com/image/article/16848914540524.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BTC20blijft20stabiel20te20midden20van20macroonzekerheden20Hong20Kongs20streven20naar20de20status20van20digitale20activahub703638"><a name="Crypto Daily Digest: BTC blijft stabiel te midden van macro-onzekerheden; Hong Kong’s streven naar de status van digitale activahub" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BTC blijft stabiel te midden van macro-onzekerheden; Hong Kong’s streven naar de status van digitale activahub</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De prijs is rond de $27.220 blijven steken, terwijl de aandelen zijn gedaald, wat wijst op beperkte liquiditeit en deelname aan de cryptomarkt. De totale marktkapitalisatie van de cryptomarkt is stabiel gebleven, met onzekerheden in het wereldwijde macrobeeld.</p>
<p>Ether is ook gebonden aan een bereik tussen $ 1.780 en $ 1.880, terwijl andere grote cryptocurrencies bescheiden winsten hebben geboekt. De correlatie tussen de S&amp;P 500 en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is afgenomen, wat wijst op een ontkoppeling tussen traditionele activa en cryptocurrencies.</p>
<p>Ondanks de volatiliteit, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Houders blijven toegewijd aan het actief. De rol van cryptocurrencies als veilige havens is echter onderwerp van debat, omdat ze niet consistent hebben opgetreden als hekken tijdens marktproblemen. De onzekerheid rond het schuldenplafond heeft crypto-activa negatief beïnvloed vanwege de versterking van de Amerikaanse dollar. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het gedrag van ‘s geeft aan dat het meer wordt gedreven door monetaire liquiditeitsfactoren dan zijn reputatie als veilige haven.</p>
<p>Intussen heeft de Securities and Futures Commission (SFC) van Hong Kong nieuwe regels geïntroduceerd die retailbeleggers in staat stellen om cryptocurrencies te verhandelen als onderdeel van haar plan om een digitale activahub te worden en haar positie als een prominent financieel centrum te herstellen. Het kader van de SFC omvat maatregelen ter bescherming van beleggers, zoals kennisproeven, risicoprofilering en blootstellingslimieten. Gelicentieerde platforms zullen moeten voldoen aan maatregelen ter bescherming van beleggers en de normen volgen die zijn vastgesteld door onafhankelijke aanbieders.</p>
<p>Vanaf 1 juni worden beurzen zonder vergunning die zich richten op beleggers in Hongkong als illegaal beschouwd. Deze verschuiving naar cryptocurrencies weerspiegelt een pragmatische aanpak van Hong Kong, gericht op het balanceren van financiële stabiliteit en innovatie. Het herstel van de crypto-industrie en het niveau van regelgevend toezicht waarmee deze in de regio te maken zal krijgen, blijven echter onzeker. Terwijl Hongkong digitale activa omarmt, leggen andere landen, zoals Singapore, beperkingen op aan de deelname van particuliere beleggers, en blijven wereldwijde regelgevers worstelen met regelgevingskaders voor de sector.</p>
<h2 id="h2-Bitcoin20BTC2027207200062020Neutrale20Outlook119636"><a name="Bitcoin (BTC) $27,207 (-0.06%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $27,207 (-0.06%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1684891505Untitled0524 1.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1684891518Untitled0524 2.png" alt=""></p>
<p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde uurlijkse ondersteuningszone: 26690 - 26570</em></strong></li><li><strong><em>Dichtstbijzijnde uurlijkse weerstandszone: 27080 - 27260</em></strong></li><li><strong><em>Sleutelniveau: 26285 (wekelijkse sluiting tussen 21-28 december 2020)</em></strong></li></ul>
<p><strong>Uurlijkse weerstandszones</strong></p>
<ol>
<li>27080 - 27260</li><li>27540 - 27660</li><li>27790 - 28020</li></ol>
<p><strong>Uurlijkse ondersteuningszones</strong></p>
<ol>
<li>26690-26570</li><li>26380 - 26120</li><li>25900 - 25818</li></ol>
<h2 id="h2-Macro20Impasse20over20Amerikaans20schuldenplafond20zorgt20voor20marktonzekerheid20handelaren20wachten20op20notulen20van20de20Fedvergadering575780"><a name="Macro: Impasse over Amerikaans schuldenplafond zorgt voor marktonzekerheid; handelaren wachten op notulen van de Fed-vergadering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Impasse over Amerikaans schuldenplafond zorgt voor marktonzekerheid; handelaren wachten op notulen van de Fed-vergadering</h2><p>Onderhandelingen over het Amerikaanse schuldenplafond zijn vastgelopen, wat heeft geleid tot een daling van zowel Amerikaanse aandelen als kortlopende schatkistpapieren. Ondanks voortdurende discussies is er beperkte vooruitgang geboekt, waarbij bepaalde Republikeinen in het Huis van Afgevaardigden de urgentie van de deadline van minister van Financiën Janet Yellen voor schuldaflossingen in twijfel trekken. Deze impasse heeft onzekerheid gecreëerd, waardoor investeerders hogere premies eisen voor het aanhouden van Amerikaanse schulden, met name die als een hoger risico op wanbetaling worden beschouwd. Als gevolg hiervan zijn de beursindices gedaald.</p>
<p>Een van de belangrijkste zorgen die voortvloeien uit de impasse is het potentieel voor een kortstondige technische standaard op het schuldenplafond. Experts waarschuwen voor toenemende marktturbulentie in de komende dagen. Deze onzekerheid heeft invloed gehad op Aziatische markten, met de verwachting van een daling als onderhandelingen over het Amerikaanse schuldenplafond vastzitten en het risicosentiment temperen. Futures voor aandelenbenchmarks in Hong Kong, Japan en Australië hebben deze pessimisme al weerspiegeld, na de daling in Amerikaanse markten.</p>
<p>Te midden van deze ontwikkelingen zijn de olieprijzen blijven stijgen, wat enige verlichting biedt. Belangrijke valuta’s daarentegen zijn relatief stabiel gebleven. De aandacht verschuift nu naar de centrale bank van Nieuw-Zeeland, die naar verwachting haar 12e opeenvolgende renteverhoging zal aankondigen. De beslissing zal nauwlettend worden gevolgd, vooral nadat de verhoogde volatiliteit de Nieuw-Zeelandse dollar op dinsdag met 0,6% deed dalen en toen een maatstaf voor de sterkte van de Amerikaanse dollar een tweemaandelijkse hoogtepunt bereikte.</p>
<p>In de VS heeft het gebrek aan voortgang in de schuldonderhandelingen zorgen geuit onder investeerders. Sommige Republikeinen in het Huis stellen de urgentie van de deadline van de minister van Financiën ter discussie, wat de complexiteit van het bereiken van een overeenkomst vergroot. Deze scepsis heeft geleid tot een vraag naar hogere premies op Amerikaanse schulden, wat het risico op een mogelijke wanbetaling verder benadrukt.</p>
<p>Omgekeerd is er positief economisch nieuws naar voren gekomen, met onverwacht stijgende verkoop van nieuwe huizen in de VS tot een meer dan een jaar hoogtepunt en aanzienlijke groei van de bedrijfsactiviteit in mei.</p>
<p>Wat betreft monetair beleid heeft de Federal Reserve aangegeven dat het de rente mogelijk hoog zal houden als inflatie meer ingebed raakt. Handelaren kijken reikhalzend uit naar de vrijgave van de notulen van de laatste vergadering van het Federal Open Market Committee, omdat dit inzicht zal geven in de toekomstige richting van de rentevoeten. Hoewel een pauze in renteverhogingen mogelijk is, zijn analisten van mening dat het herstarten van de renteverhogingen aanzienlijke rechtvaardiging zou vereisen gezien de huidige economische omgeving.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Peter L. </strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>