RGFnZWxpamtzIG5pZXV3cyB8IEZlZC1iZXNsdWl0IG5hZGVydCB0ZXJ3aWpsIEJpdGNvaW4gc3RhYmllbCBibGVlZiB0ZSBtaWRkZW4gdmFuIG5lZ2F0aWV2ZSBmaW5hbmNpZXJpbmdzcmVudGVzLCBGcmF4IGJlw6tpbmRpZ3QgZXhwZXJpbWVudGVuIG1ldCBhbGdvcml0bWlzY2hlIHN0YWJpZWxlIG11bnRlbg==

2023-03-07, 02:09

<p><img src="https://gimg2.gateimg.com/image/article/16781548700307.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Bitcoin2020Handhaaft20stabiliteit20te20midden20van20negatieve20financieringstarieven20besluit20van20de20Fed20om20de20toekomst20van20de20markt20te20bepalen591072"><a name="Crypto Dagelijkse Samenvatting:   Bitcoin  Handhaaft stabiliteit te midden van negatieve financieringstarieven, besluit van de Fed om de toekomst van de markt te bepalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Handhaaft stabiliteit te midden van negatieve financieringstarieven, besluit van de Fed om de toekomst van de markt te bepalen</h2><p>Goedemorgen, handelaren! Laten we deze dinsdag meedogenloos grijpen en er het beste van maken! 🚀</p>
<p>De recente rally op de aandelenmarkt is niet in staat geweest om stand te houden vanwege economische risico’s en druk van stijgende rendementen op staatsobligaties. Hoewel technische factoren op korte termijn enige ondersteuning kunnen bieden, blijven de fundamenten verslechteren. Het verschil tussen BBB-beoordeelde dollar-gedenomineerde bedrijfsschulden en de beschikbare winst op de S&amp;P 500 is nu boven nul, wat duidt op voorzichtigheid over hoe wereldwijde financiële activa en de economie zich kunnen ontwikkelen. De komende beslissing van de Federal Reserve en vier belangrijke gebeurtenissen zullen bepalen of het herstel van de aandelenmarkt in 2023 wordt ontspoord of weer op gang komt na een inzinking in februari.</p>
<p>Aziatische aandelenmarkten worden verwacht dat ze een gedempte opening hebben na een matige handel op Wall Street. Australische aandelen openden lager, terwijl de aandelenfutures voor Japan iets lager waren. Hong Kong futures boekten een bescheiden winst, ondanks een daling van 1,7% in een index van in de VS verhandelde aandelen van Chinese bedrijven. De Reserve Bank of Australia wordt verwacht dat het zijn rentetarief met nog eens een kwart punt verhoogt naar 3,60%, voordat het in april piekt op 3,85%. Later op dinsdag zal Fed-voorzitter Jerome Powell twee dagen lang getuigenis afleggen voor de senaats- en huiscommissies.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en Ether begon de week met handelen binnen een nauwe marge met weinig overtuiging in welke richting dan ook, weerspiegeld in lage handelsvolumes. Het negatieve sentiment blijft de markten overschaduwen na de ontvouwing van de activabasis van Silvergate Bank, maar investeerders herprijzen risico’s in plaats van de markten te verlaten. On-chain activiteit impliceert dat de vraag nog steeds aanhoudt binnen de cryptoruimte, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Transfer Volume (BTV) is dit jaar met 79% gestegen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> klom maandag tot een piek van meer dan $22.500, maar daalde vervolgens lichtjes en bleef sinds donderdag in een nauwe marge. De financieringstarieven van BTC en ETH werden vorige week negatief, wat een teken is van pessimistisch marktsentiment. De sluiting van het Silvergate Exchange Network had echter geen significante invloed op de prijs van BTC.</p>
<p>Ondertussen wordt verwacht dat de beslissing van Silvergate Capital om zijn directe afwikkelingsservice stop te zetten, de rol van stablecoins en hun uitgevers in crypto-handel zal vergroten. Deze stablecoins, zoals <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT van ‘s werelds grootste cryptocurrency exchange, Gate.io, en USDC van Circle, hebben de rol overgenomen van door de overheid uitgegeven fiatvaluta’s zoals de Amerikaanse dollar als de belangrijkste valuta in de cryptomarkt. Het rapport benadrukt ook de afnemende rol van de Amerikaanse dollar in de cryptohandel, waarbij handelaren er nu voor kiezen om fondsen over te maken naar stablecoin-uitgevers om stablecoins te verkrijgen en deze op beurzen te storten. Het rapport waarschuwt echter ook dat deze verschuiving risico’s met zich meebrengt, aangezien stablecoin-uitgevers nog steeds toegang nodig hebben tot een crypto-bank.</p>
<h2 id="h2-Onderwerp20van20de20dag202020Frax2020Einde20van20het20experimenteren20met20algoritmestabiele20munten475817"><a name="Onderwerp van de dag:   Frax  Einde van het experimenteren met algoritme-stabiele munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Einde van het experimenteren met algoritme-stabiele munten</h2><p><a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, een gedecentraliseerd stablecoin-platform, heeft een belangrijke beslissing genomen om zijn FEI stablecoin te ondersteunen met USD-equivalenten, waarmee een einde komt aan het experimenteren met algoritme-gedreven stablecoins. Deze stap heeft het potentieel om het vertrouwen in stablecoins te vergroten en het gebruik van DeFi-toepassingen te bevorderen. Een volledig gedekte stablecoin kan ook helpen om risico’s voor investeerders te verminderen door de depegging en waardeverlies te beperken.</p>
<p>Echter heeft het falen van algorithmische stablecoins zoals UST en overbelaste stablecoins zoals MIM het vertrouwen in gedecentraliseerde stablecoins aangetast. Gedecentraliseerde stablecoins maken slechts een klein percentage uit van het totale aanbod aan stablecoins en de transfer volumes zijn gedaald sinds Q3 2022, wat wijst op uitdagingen bij het verkrijgen van marktaandeel. Daarnaast blijven reguleringsrisico’s, zoals blijkt uit een recente gerechtelijke uitspraak in Engeland die MakerDAO heeft beïnvloed, een zorg.</p>
<p>Terwijl <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> De beslissing van Gate.io om zijn stablecoin volledig te ondersteunen heeft positieve implicaties, maar er zijn ook potentiële uitdagingen om rekening mee te houden, zoals het herstellen van het vertrouwen in gedecentraliseerde stablecoins en het omgaan met regelgevingsrisico’s.</p>
<h2 id="h2-Frax20Share20FXS209684200912020Neutraal20vooruitzicht868034"><a name="Frax Share (FXS) $9,684 (+0,91%) - Neutraal vooruitzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/frax-share-fxs" rel="nofollow noopener noreferrer" target="_blank">Frax Share</a>(FXS) $9,684 (+0,91%) - Neutraal vooruitzicht</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 9.392 - 9.020</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszone: 9.942 - 10.567</em></strong></li><li><strong><em>Sleutelniveau: 9.392 (Maandelijkse afsluiting van mei 2021)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1678154930Untitled0307.png" alt=""></p>
<p>Ondanks een bijna 20% daling tussen afgelopen donderdag en zondag, heeft FXS veerkracht getoond door boven het maandelijkse niveau van 9.392 te blijven. Echter, het huidige prijsniveau bevindt zich in de nabijheid van het lagere einde van de wekelijkse Fibonacci-uitgebreide gouden zone, die varieert van 9.020 tot 11.865 en sinds de doorbraak op 19 januari een cruciaal consolidatiegebied is geweest. Als FXS onder zijn huidige prijsniveau zakt, zal het waarschijnlijk mikken op het wekelijkse niveau van 8.160. Als alternatief, als FXS herstelt van zijn huidige prijsniveau, zal het een aanzienlijke hindernis tegenkomen in de dagelijkse Fibonacci-gouden zone van 10.567 tot 11.191, die zal helpen bepalen of het herstel een valstrik voor stieren is.</p>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>9.942 - 10.567</li><li>10.879 - 11.191</li><li>11.865 - 13.210</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>9.392 - 9.020</li><li>0.384</li><li>7.611 - 7.263</li></ol>
<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 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>