RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gZG9taW5hbnRpZSBzdGlqZ3QsIGFsdGNvaW5zIGR1aWtlbiB0aWpkZW5zIGNlbnRyYWxlIGJhbmsgYmlqZWVua29tc3RlbiBlbiBpbmZsYXRpZXpvcmdlbg==

2023-06-12, 00:47

<p><img src="https://gimg2.gateimg.com/image/article/16865306130612.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Bitcoin20Dominantie20Stijgt20Terwijl20Crypto20Markt20Volatiel20is911598"><a name="Crypto Dagelijkse Samenvatting: Bitcoin Dominantie Stijgt Terwijl Crypto Markt Volatiel is" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Dominantie Stijgt Terwijl Crypto Markt Volatiel is</h2><p>In een recente wending van gebeurtenissen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De dominantie van Bitcoin op de cryptomarkt is gestegen naar bijna 50%, waarmee het zijn hoogste niveau heeft bereikt sinds april 2021. Deze stijging viel samen met aanzienlijke verliezen die werden geleden door alternatieve cryptocurrencies, zoals SOL, MATIC, DOGE en ADA. Marktplaatsgeruchten suggereren dat deze verliezen werden veroorzaakt door een enorme dump van het portefeuille van $2 miljard door een eigenhandelbedrijf.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1686530662Untitled0612 1.png" alt=""></p>
<p>Terwijl altcoins dubbelcijferige verliezen leden, toonde Bitcoin veerkracht met slechts een daling van 3%. Deze relatieve outperformance kan worden toegeschreven aan toenemende vraag van investeerders die een veilige haven zoeken te midden van de marktturbulentie. Opvallend is dat deze trend van investeerders die zich verzamelen rond grote cryptocurrencies vóór mogelijke marktcrashes, duidt op een vlucht naar veiligheid.</p>
<p>De dominantie van Bitcoin is sinds november gestaag gestegen, met een opmerkelijke stijging tijdens de bankencrisis in maart in de Verenigde Staten. De recente stijging in dominantie suggereert dat Bitcoin klaar is voor aanhoudende overperformance in de komende maanden. Deze ontwikkeling duidt op een mogelijke breuk met het driejarige oscillatiepatroon dat wordt waargenomen in het dominantiepercentage van Bitcoin, wat het vertrouwen in zijn prestaties verder versterkt.</p>
<p>Temidden van deze marktbewegingen, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>, ‘s werelds grootste op de dollar gekoppelde stablecoin, ondervond ook een stijging in dominantie en bereikte het hoogste niveau sinds 8 januari. Dit duidt erop dat investeerders zich tijdens periodes van marktvolatiliteit naar stablecoins als een veilige haven begeven.</p>
<p>In een afzonderlijke ontwikkeling hebben belangrijke tokens op verschillende blockchain-netwerken een aanzienlijke daling doorgemaakt, met verliezen van meer dan 20% sinds afgelopen vrijdag. De duik kan worden toegeschreven aan een risicovol evenement dat werd veroorzaakt door recente rechtszaken die zijn aangespannen door de U.S. Securities and Exchange Commission (SEC) tegen crypto-beurzen Binance en Coinbase. De beschuldigingen van de SEC dat 13 tokens, waaronder SOL, MATIC, ADA en anderen, effecten zijn, hebben marktspanningen veroorzaakt en de verkoop gestimuleerd.</p>
<p>Als gevolg van de SEC-deponeringen hebben platforms zoals Robinhood de ondersteuning stopgezet voor tokens die door de regelgevende maatregelen zijn getroffen, wat de markt nog onzekerder maakt. De gevolgen waren voelbaar op de crypto-futuresmarkt, met bijna $ 300 miljoen aan liquidaties, waarmee het vorige record van negen maanden werd overtroffen.</p>
<p>Uit de analyse van blockchain-gegevens bleek dat belangrijke marktmakers, waaronder Jump Trading en Cumberland, aanzienlijke bedragen hebben gestuurd. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Veelhoek</a> (MATIC) naar verschillende crypto-uitwisselingen. Deze toestroom van tokens, mogelijk verkocht te midden van illiquide marktomstandigheden, heeft bijgedragen aan de scherpe daling van de prijs van MATIC. Soortgelijke prijsbewegingen werden waargenomen in <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA) en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL) tokens, die ook aanzienlijke dalingen hebben ervaren.</p>
<p>Ondanks de huidige volatiliteit zet Hong Kong stappen om zichzelf te positioneren als een crypto-vriendelijke jurisdictie. Lid van de Wetgevende Raad Johnny Ng heeft een uitnodiging uitgebreid naar Coinbase en andere crypto-beurzen, waarbij hij hen aanspoorde om activiteiten in de regio op te zetten. Hong Kong is actief bezig met het formuleren van regelgeving en het implementeren van nalevingsmaatregelen om de groei van de cryptocurrency-industrie te bevorderen. De Hong Kong Monetary Authority (HKMA) heeft onlangs plannen aangekondigd om de introductie van een retail central bank digital currency (CBDC) te verkennen en de toegang van klanten tot cryptocurrency-beurzen te vergemakkelijken.</p>
<p>De gunstige crypto-positie in Hong Kong heeft interesse gewekt bij internationale technologiebedrijven. De Zuid-Koreaanse techgigant Samsung introduceerde bijvoorbeeld eerder dit jaar een Bitcoin futures actief beursgenoteerd fonds op de Hong Kong Stock Exchange. Bovendien onderstreept de erkenning van Chinese overheidsfunctionarissen verder de betekenis van de initiatieven van Hong Kong in het bredere digitale valutalandschap.</p>
<h2 id="h2-Bitcoin20BTC2025879200152020Neutraal20vooruitzicht688284"><a name="Bitcoin (BTC) $25,879 (+0,15%) - Neutraal vooruitzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC) $25,879 (+0,15%) - Neutraal vooruitzicht</h2><p><img src="https://gimg2.gateimg.com/image/article/1686530807Untitled0612 2.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1686530820Untitled0612 3.png" alt=""></p>
<p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 25818 - 25360</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszone: 26280 - 26700</em></strong></li><li><strong><em>Sleutel Niveau: 25270 (Dagelijkse 200EMA)</em></strong></li></ul>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>26280 - 26700</li><li>26970 - 27265</li><li>27790 - 28420</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>25818 - 25360</li><li>25240 - 24270</li><li>23855 - 23470</li></ol>
<h2 id="h2-Macro20Feds20pauzeplan20in20focus20terwijl20handelaren20centrale20bankvergaderingen20in20de20gaten20houden430660"><a name="Macro: Fed’s pauzeplan in focus terwijl handelaren centrale bankvergaderingen in de gaten houden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fed’s pauzeplan in focus terwijl handelaren centrale bankvergaderingen in de gaten houden</h2><p>Aziatische aandelen staan op het punt om voorzichtig te beginnen, terwijl handelaren wachten op belangrijke rentebeslissingen van centrale banken. Hoewel werd verwacht dat de Japanse aandelen een lichte stijging zouden ervaren, werd verwacht dat de Hongkongse aandelen een kleine daling zouden zien. De Australische markten bleven gesloten vanwege een feestdag, wat bijdroeg aan de ingetogen handelssentiment.</p>
<p>Technologieaandelen daarentegen bleven hun opwaartse traject voortzetten, omdat beleggers wedden op het einde van de renteverhogingscyclus van de Amerikaanse Federal Reserve. Dit sentiment werd ondersteund door posities op rentemarkten, die wezen op de mogelijkheid van nog één verhoging, mogelijk in de volgende maand in plaats van tijdens de aanstaande vergadering. Er waren echter zorgen over de mogelijke gevolgen van de eerdere renteverhogingen van de Fed, waarbij obligatiebeheerders, waaronder Fidelity International en Allianz Global Investors, waarschuwden voor een komende economische neergang. De onverwachte renteverhogingen door de Bank of Canada en de Reserve Bank of Australia in de voorgaande week voegden nog een element van onzekerheid toe.</p>
<p>Deze week zit vol met beslissingen van centrale banken. De Europese Centrale Bank zal naar verwachting donderdag haar referentietarief verhogen, terwijl er een mogelijkheid is dat China diezelfde dag haar faciliteit voor middellangetermijnleningen verlaagt. De Bank of Japan daarentegen wordt verwacht haar huidige standpunt te handhaven en vrijdag de tarieven ongewijzigd te laten.</p>
<p>In de valutamarkten werden belangrijke valuta’s zoals de dollar, yen, euro en offshore yuan verhandeld binnen smalle marges, wat wijst op een gebrek aan significante volatiliteit. Ondertussen vertoonden de rendementen op staatsobligaties een lichte stijging na teleurstellende werkgelegenheidsgegevens uit Canada, waaruit bleek dat er in mei sprake was van een kleine banenverlies, wat wijst op zwakte op de arbeidsmarkt.</p>
<p>Alle ogen zijn nu gericht op de komende vergadering van de Federal Reserve. Algemeen werd verwacht dat de Fed de rente ongewijzigd zou laten, wat een pauze in de renteverhogingscyclus inluidde. Het besluit van de centrale bank zou dienen als een gelegenheid om de recente spanningen in de banksector te beoordelen en de vooruitgang te ueren die is geboekt bij het beteugelen van de inflatie. Sommige functionarissen binnen de Fed uitten echter hun bezorgdheid dat de vooruitgang van de inflatie tot stilstand was gekomen en waren van mening dat verdere maatregelen nodig zouden kunnen zijn om de veerkrachtige economie af te koelen.</p>
<p>De recente gegevens van de Fed over inflatie en de sterkte van de arbeidsmarkt, gecombineerd met de signalen van voorzitter Jerome Powell en gouverneur Phillip Jefferson, hebben de marktverwachtingen veranderd. Wat aanvankelijk werd gezien als een pauze in renteverhogingen, werd nu heroverwogen, met de mogelijkheid van een renteverhoging in juli die terrein wint. Powell stond voor de uitdaging om de bedoelingen van de Fed effectief over te brengen, vooral als de beslissing om te pauzeren is genomen. De publicatie van het rapport over de consumentenprijsindex in mei, samen met de vergadering, kan het besluitvormingsproces van de Fed verder beïnvloeden. Een hogere lezing in het inflatierapport zou beleidsmakers kunnen aanzetten om het pauzeplan te laten varen en verder te gaan met nog een renteverhoging van 25 basispunten.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 glen zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>