RGFpbHkgTmV3cyB8IFhSUCB6aWV0IGVyIGJ1bGxpc2ggdWl0IGluIGhldCBRMS1yYXBwb3J0LCBQRVBFIHN0ZWVsdCBkZSBrcm9vbiB2YW4gTWVtZSBDb2lu

2023-05-01, 01:24

<p><img src="https://gimg2.gateimg.com/image/article/16829040100501.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht202020XRP2020Q1marktrapport20duidt20op20een20bullish20traject20ondanks20dreigende20rechtszaak20PEPE20Coin20neemt20Meme20Coinkroon20over20van20DOGE20en20SHIB20Bhutan20heeft20stilletjes20BTC20gedolven20sinds20het205k20was717546"><a name="Crypto Dagelijks Overzicht:   XRP  Q1-marktrapport duidt op een bullish traject ondanks dreigende rechtszaak; PEPE Coin neemt Meme Coin-kroon over van DOGE en SHIB; Bhutan heeft stilletjes BTC gedolven sinds het $5k was" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Q1-marktrapport duidt op een bullish traject ondanks dreigende rechtszaak; PEPE Coin neemt Meme Coin-kroon over van DOGE en SHIB; Bhutan heeft stilletjes BTC gedolven sinds het $5k was</h2><p>Crypto-markten kenden een lichte prijsstijging na een periode van prijsstagnatie en dalingen eerder vandaag, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kortstondig weer boven de $29.900 uitkomen na een dip rond de $29.270. Ether maakte ook een vergelijkbare handelstraject door, wat leidde tot handel op een gemiddelde van $1.905 voordat het zich terugtrok richting $1.935.</p>
<p>De volatiele handelstraject kan worden toegeschreven aan de Britse overheid en soortgelijke internationale regelgevende instanties die verder afkoelen op crypto, met aanscherping van de regelgeving en een gebrek aan beschikbaarheid, met name in het Verenigd Koninkrijk, na de door de FCA uitgegeven crypto-due diligence brief in 2018 aan banken. Op een meer positieve institutionele noot heeft de EU echter onlangs de Markets in Crypto Assets-regelgeving (MiCA) aangenomen, wat resulteert in een geheel nieuw vergunningenstelsel in alle 27 lidstaten, wat het potentieel heeft om het Europese cryptolandschap te veranderen en de ontwikkeling te versterken.</p>
<p>Afwijken van deze volatiliteit is echter het eerste kwartaal van 2023 <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Marktrapportgegevens uitgegeven op de 27e, waarin verschillende belangrijke ontwikkelingen worden belicht. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> De marktaanwezigheid van Ripple. Ripple zag <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> de verkoop steeg naar een nettobedrag van $361,06 miljoen, vergeleken met de $226,31 miljoen van het vorige kwartaal. Daarnaast, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> de activiteit op de blockchain steeg met 34% tot $115 miljoen in vergelijking met het vorige kwartaal. Als gevolg hiervan, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Het gemiddelde dagelijkse volume van ‘s werelds grootste centrale beurzen steeg met 46% naar $1 miljard in vergelijking met $698 miljoen in het vierde kwartaal van 2022.</p>
<p>In het licht van deze positieve bullish gegevens, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> is afgeweken van de bredere financiële onrust die respectievelijk in de crypto- en traditionele markten is waargenomen. Deze bullish gegevens kunnen wijzen op belangrijke tekenen van prijsherstel voor <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> en groeiende kracht ondanks het aanstaande vonnis in de rechtszaak Ripple vs SEC.</p>
<p>Op een vergelijkbaar bullish noot, heeft de PEPE meme coin de crypto wereld overrompeld, met een stijging van 38.900% sinds de lancering op 14 april. Nu gerangschikt als de 17e meest verhandelde crypto, heeft PEPE een marktkapitalisatie van $337 miljoen bereikt en jaagt het snel de vier meme coins voor hem na, met een handelsvolume van slechts $8 miljoen minder dan zijn concurrent FLOKI in de afgelopen 24 uur. PEPE is een activum om in de komende weken in de gaten te houden.</p>
<p>Echter, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> nog steeds niet in staat om boven de weerstandszone van $30k te blijven, kan het bredere marktherstel achterblijven bij enkele uitzonderingen. Toch kan dit veranderen als gevolg van internationale adoptie. Op de 28e meldde The Bhutanese dat Druk Holding and Investments (DHI), het grootste en enige door de overheid eigendom holdingbedrijf van Bhutan, aan het mijnen is. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> om zijn beleggingsportefeuille te diversifiëren. Volgens het rapport is DHI geïnteresseerd in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> begon toen de oorspronkelijke crypto slechts $5k waard was, maar ze hebben ook een kleine interesse in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> DHI heeft bevestigd dat hun interesse beperkt is tot mijnbouw en technologie alleen, waarbij het bedrijf zich niet affilieert met enige directe koop of verkoop van digitale activa.</p>
<p>Dit niveau van institutioneel belang en adoptie van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De technologie van ‘s zou misschien een voorbode kunnen zijn van andere landen die op de cryptotrein springen en beginnen te profiteren van de technologie. Dit zou steeds meer mogelijk kunnen worden met de introductie van nieuwe wetgeving in de EU, de VAE en het Verenigd Koninkrijk, aangezien crypto lijkt een populairder onderwerp dan ooit tevoren te zijn. Dit zou kunnen leiden tot meer internationale adoptie en mogelijk een kleine marktherstel en toestaan. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> om boven de kritieke drempel van $30k te duwen.</p>
<h2 id="h2-XRP2020202020XRP202004724201272020Neutrale20Outlook579143"><a name="XRP  (   XRP ) $0.4724 (-1.27%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) $0.4724 (-1.27%) - Neutrale Outlook</h2><p><img src="https://gimg2.gateimg.com/image/article/1682904092screenshot-20230501-092114.png" alt=""><br>(Data met dank aan TradingView)</p>
<p>Vanaf vandaag, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> handelt momenteel dichter bij zijn ondersteuning dan bij zijn weerstand, wat erop wijst dat de beren niet opgeven. Als de bar in de buurt van het niveau van $0,4742 sluit, is het mogelijk <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> kan de volgende dag dalen naar de $0,47 zone. Vanuit een middellangetermijnperspectief, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> is opgeveerd van de ondersteuningszone van $0,4428, terwijl de prijs boven dit niveau blijft, hebben kopers de mogelijkheid om de dip te grijpen. Op een groter tijdsbestek blijft de prijs van <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> is geleidelijk gedaald na een valse doorbraak in de weerstandszone van $0.4854. Als de prijs er niet in slaagt om te herstellen tot $0.48, zou de daling mogelijk kunnen leiden tot een test van de $0.46 drempel. Uiteindelijk moet de koers boven de $0.50 zone worden vastgesteld om mogelijk tot een ommekeer te leiden.</p>
<h3 id="h3-Overzicht743404"><a name="Overzicht:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht:</h3><p><strong>Dichtstbijzijnde uurlijkse ondersteuningszone: 0,4714-0,4717</strong><br><strong>Dichtstbijzijnde uurlijkse weerstandszône: 0,4755-0,4764</strong><br><strong>Belangrijk niveau: 0,5697 (3-maandelijks hoog)</strong></p>
<p><strong>Uurlijkse weerstandszones</strong><br>0.4760-0.4762<br>0.4748-0.4751<br>0.4722-0.4724</p>
<p><strong>Uurlijkse ondersteuningszones</strong><br>0.4762-0.4763<br>0.4714-0.4717<br>0.4722-0.4723</p>
<h2 id="h2-Macro20Fed20Triggers20Wereldwijde20Ramp20Als20Landen20Terugdeinzen20Voor20Amerikaanse20Obligaties343895"><a name="Macro: Fed Triggers Wereldwijde Ramp Als Landen Terugdeinzen Voor Amerikaanse Obligaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fed Triggers Wereldwijde Ramp Als Landen Terugdeinzen Voor Amerikaanse Obligaties</h2><p>Miljardair Ray Dalio heeft investeerders gewaarschuwd dat de interesse in de aankoop van Amerikaanse staatsobligaties is afgenomen na de recente crisis in de Amerikaanse banksector, doordat het bepalende bedrijf Silicon Valley Bank is opgeheven. Dalio dringt er bij investeerders op aan te begrijpen dat de crash van het voormalige bedrijf slechts een symptoom is van een veel groter probleem dat is veroorzaakt door de Federal Reserve. Dalio suggereert dat de historische stijging van de rentetarieven in het afgelopen jaar heeft geleid tot een dramatische duatie van de obligaties die door de overheid aan bedrijven worden verkocht. Normaal gesproken bewegen obligatieprijzen en rentetarieven tegen elkaar in, waarbij de ene stijgt terwijl de andere daalt, wat vaak leidt tot de uitgifte van nieuwe obligaties die een hoger rendement bieden.</p>
<p>Dalio verklaarde: “Als je naar het probleem van de Silicon Valley Bank kijkt, is het niet zozeer hun probleem als wel een wereldwijd probleem… Er is een strak monetair beleid en die rendementen zijn gestegen en de obligaties zijn in waarde gedaald, en daardoor is het bedrag dat ze moeten uitkeren in waarde gestegen, en zo zijn ze failliet gegaan. Dat gebeurt overal… Hetzelfde soort dingen gebeurden in Europa… gebeurde met (Japan), bedrijven die zelfs Amerikaanse dollarobligaties kochten.”</p>
<p>Volgens Dalio hebben de strakke monetaire beleidsmaatregelen van de Feds een catastrofale omgeving gecreëerd voor de Amerikaanse economie, waarvan het ripple-effect nog volledig moet worden gevoeld in de hele economie en diverse investeringsmarkten.</p>
<p>In andere markten stegen de olie- en goudprijzen beide gemiddeld met respectievelijk 2,7%.</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 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 genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>