RGFnZWxpamtzIG5pZXV3cyB8IEdyb3RlIEFtZXJpa2FhbnNlIGJhbmsgb250aHVsdCBkYXQgJ2VlbiBuaWV1d2UgZ29sZicgZWVuIGFhcmRiZXZpbmcgdmFuICQxNSBiaWxqb2VuIGthbiB2ZXJvb3J6YWtlbiB2b29yIGRlIGNyeXB0b2JyYW5jaGUsIGRlIEFtZXJpa2FhbnNlIGNvbW1pc3NpZSB2YW4gaGV0IEh1aXMgYmVyZWlkdCB6aWN

2023-06-23, 01:19

<p><img src="https://gimg2.gateimg.com/image/article/16874828390623.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Grote20Amerikaanse20Bank20Onthult20Een20Nieuwe20Golf20Die20Een201520Biljoen20Aardbeving20Voor20De20Cryptocurrency20Industrie20Kan20Veroorzaken261522"><a name="Crypto Dagelijkse Samenvatting: Grote Amerikaanse Bank Onthult ‘Een Nieuwe Golf’ Die Een $15 Biljoen Aardbeving Voor De Cryptocurrency Industrie Kan Veroorzaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Grote Amerikaanse Bank Onthult ‘Een Nieuwe Golf’ Die Een $15 Biljoen Aardbeving Voor De Cryptocurrency Industrie Kan Veroorzaken</h2><p>Na de aankondiging van BlackRock over de implementatie van de EDX-uitwisseling en hun voortdurende inspanningen voor een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF, de cryptocurrency markt is gestegen in <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, wat leidt tot aanzienlijke prijsstijgingen en bullish sentiment onder investeerders en analisten. In lijn met BlackRock’s pro-crypto initiatieven, nemen verschillende andere grote vermogensbeheerders en traditionele financiële (TradFi) bedrijven een plakje van de cryptotaart, waardoor de cryptomarkt klaar is voor enorme instromen en algemene acceptatie volgens een enquête uitgevoerd door Laser Digital, waaruit blijkt dat 96% van de professionele beleggers die bijna $5 biljoen beheren, geïnteresseerd zijn om te investeren in cryptocurrencies, bovenop de bijna $10 biljoen aan activa onder beheer van BlackRock die mogelijk worden opengesteld voor de cryptomarkt.</p>
<p>Met deze enorme momentum en optimisme, activa zoals BTC, ETH, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, ADA, DOGE, <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>, SOL en MATIC hebben allemaal aanzienlijk bullish prijsvoorspellingen ontvangen, waarvan analisten voorspellen dat ze ‘zeer snel’ kunnen plaatsvinden. De CEO van Laser Digital, Jez Mohidden, verklaarde in een rapport aan CoinDesk: ‘Onze uitgebreide studie toont aan dat de meerderheid van de institutionele beleggers die we hebben ondervraagd een duidelijke rol ziet voor digitale activa in het beheer van investeringen, en de voordelen die ze kunnen bieden, zoals een grotere diversificatie van portefeuilles.’</p>
<p>De 303 professionele beleggers die zijn ondervraagd, vertegenwoordigen een groep die $4,95 biljoen aan activa beheert, waarbij 82% van de beleggers een positieve kijk heeft op zowel <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> als <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, waarbij nog eens 88% aangeeft dat zijzelf of hun klanten overwegen te investeren in cryptocurrency.</p>
<p>Met grote institutionele TradFi-spelers zoals BlackRock die cryptocurrency-integratie op een gereguleerde manier nastreven door goedkeuring te zoeken van de SEC, heeft hun interesse de crypto-industrie op gang gebracht en de enthousiasme opnieuw aangewakkerd die de afgelopen maanden geleidelijk uit de cryptomarkt is weggenomen als gevolg van regelgevende acties van de SEC en diverse verwoestende prijs crashes.</p>
<p>In reactie op de kwestie verklaarde Alex Adelman, de chief utive van de Bitcoin-rewards-app Lolli: “Als ‘s werelds grootste vermogensbeheerder toont het initiatief van BlackRock om een Bitcoin ETF in te dienen aan dat er steeds meer sterke vraag is naar blootstelling aan Bitcoin onder zijn cliënten, waaronder enkele van de grootste instellingen ter wereld.”</p>
<h2 id="h2-Technisch20overzicht20Bitcoin20BTC203004453200412020Neutraal20vooruitzicht709010"><a name="Technisch overzicht: Bitcoin (BTC) $30,044.53 (+0.41%) - Neutraal vooruitzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Technisch overzicht: Bitcoin (BTC) $30,044.53 (+0.41%) - Neutraal vooruitzicht</h2><p><img src="https://gimg2.gateimg.com/image/article/16874829633821687482909_.pic.jpg" alt=""><img src="https://gimg2.gateimg.com/image/article/16874829753831687482938_.pic.jpg" alt=""></p>
<p>Vanaf vandaag heeft Bitcoin de 20-daagse exponentiële voortschrijdend gemiddelde (EMA) van $26.934 doorbroken en gesloten en is gestegen naar een dagelijkse hoogte van $30.613. Na weerstand van de beren op de 18e, is Bitcoin teruggekeerd naar het bullish kanaal. Sindsdien is er agressief gekocht, wat aanvankelijk werd aangewakkerd op 20 juni en tot op heden voortduurt, wat wijst op een kortetermijntrendverandering. Het is waarschijnlijk dat de beren zullen proberen het huidige niveau fel te verdedigen en Bitcoin weer onder de weerstand van $30.000 te duwen. Echter, als de stieren hun huidige optimistische momentum kunnen behouden, heeft Bitcoin het potentieel om naar de volgende kritieke weerstandszone van $38.000 te stijgen. Toch zouden de beren potentieel de stieren kunnen vangen en de prijs onder de voortschrijdende gemiddelden kunnen terugtrekken, wat zou kunnen leiden tot langdurige liquidatie en de $25.250 ondersteuningszone zou bedreigen.</p>
<p><strong>Overzicht:</strong></p>
<p><strong>Dichtstbijzijnde dagelijkse steungebied: 30063 - 30143</strong><br><strong>Dichtstbijzijnde dagelijkse weerstandzone: 30318 - 30240</strong><br><strong>Belangrijk niveau: 30613 (Dagelijkse hoogste, Hoogste in zes weken)</strong></p>
<p>Dagelijkse weerstandszones<br>30375 - 30484<br>30318 - 30240<br>30115 - 30227</p>
<p>Dagelijkse ondersteuningszones<br>30304 - 30385<br>30063 - 30143<br>30046 - 30108</p>
<h2 id="h2-Macro20Amerikaanse20Huiscommissie20bereidt20zich20voor20op20belangrijke20stemming20over20regelgeving20voor20digitale20activa3442"><a name="Macro: Amerikaanse Huiscommissie bereidt zich voor op belangrijke stemming over regelgeving voor digitale activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse Huiscommissie bereidt zich voor op belangrijke stemming over regelgeving voor digitale activa</h2><p>De financiële commissie van het Amerikaanse Huis van Afgevaardigden zal stemmen over nieuwe wetgeving die tot doel heeft een duidelijkere weg te banen voor digitale activa om van de status van effecten naar een grondstof te gaan, evenals het vaststellen van een uitgebreid regelgevend kader voor stablecoins. Een tak van de Amerikaanse congrescommissie die nieuwe regels opstelt voor digitale activa, is van plan om twee nieuwe voorgestelde wetten te bespreken en mogelijk vooruit te helpen.</p>
<p>De voorzitter van het House Financial Services Committee, Patrick McHenry, R-NC., vertelde zijn panel eerder vandaag dat hij van plan is een sessie te coördineren die gericht is op debat, verandering en waarschijnlijk het bevorderen van wetgeving die de transformatie van crypto’s van beveiligingsbeleggingsstatus naar grondstoffen zou bevorderen, die lagere rapportage- en regelgevingsvereisten hebben, samen met andere bepalingen met betrekking tot de marktstructuur.</p>
<p>Echter zal er een aparte tak van discussie worden gevoerd die volledig zal draaien rondom stablecoins, waarbij waarschijnlijk gekeken wordt naar de reeks verwoestende de-peggings en uitgebreide oplichtingspraktijken die stablecoins in de vergetelheid hebben doen belanden en investeerders voor miljarden dollars hebben opgelicht. In een apart wetsvoorstel zullen McHenry en voorzitter van de Federal Reserve Jerome Powell, R-Ark, voornamelijk dit wetsvoorstel samen schrijven als een middel om regelgeving voor stablecoins uit te werken en het voorstel naar het voltallige Huis van Afgevaardigden te brengen.</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 genoemd. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>