RGFnZWxpamtzIG5pZXV3cyB8IENlbnRyYWxlIGJhbmtlbiBwcm9iZXJlbiBoZXQgbWFya3R2ZXJ0cm91d2VuIHRlIHZlcmdyb3RlbiwgQml0Y29pbiBzY2hvbW1lbHQgdm9vcmFmZ2FhbmQgYWFuIEZPTUMsIERXRiBMYWJzIGludmVzdGVlcnQgaW4gU3ludGhldGl4

2023-03-21, 01:53

<p><img src="https://gimg2.gateimg.com/image/article/16793633530321.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Centrale20Banken20Wereldwijd20Ondernemen20Actie20om20Marktvertrouwen20te20Stimuleren202020Tegen20Bitcoin2020en20Ether20Daling385493"><a name="Crypto Dagelijks Overzicht: Centrale Banken Wereldwijd Ondernemen Actie om Marktvertrouwen te Stimuleren,   Tegen Bitcoin  en Ether Daling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Centrale Banken Wereldwijd Ondernemen Actie om Marktvertrouwen te Stimuleren, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> en Ether Daling</h2><p>Goedemorgen, handelaren! Laten we deze dinsdag meedogenloos grijpen en er het beste van maken! 🚀</p>
<p>Na de recente financiële onrust hebben centrale banken wereldwijd maatregelen genomen om het marktvertrouwen te vergroten, wat heeft geleid tot een stijging van de aandelenkoersen. De S&amp;P 500-index heeft winst geboekt in alle 11 groepen en Amerikaanse geldschieters hebben zich hersteld na een daling van 15% de vorige week. Veel beleggers geloven dat de bankcrisis niet isch is en dat er een oplossing zal worden gevonden om de schade te beperken.</p>
<p>Bovendien heeft het Federal Home Loan Bank  vorige week $304 miljard aan schulden uitgegeven, bijna het dubbele van de $165 miljard die liquiditeitshongerige kredietverstrekkers van de Federal Reserve hebben geleend. De FHLB is een door de Amerikaanse overheid gesponsord orgaan dat financiering biedt aan andere banken en financiële instellingen ter ondersteuning van woningfinanciering en economische ontwikkeling. Deze grote schuldenuitgifte geeft aan dat financiële instellingen op zoek zijn naar alternatieve financieringsbronnen, zoals de FHLB, nu de liquiditeit van de Federal Reserve schaars wordt.</p>
<p>Aziatische aandelen worden ook verwacht te stijgen na de winsten op Wall Street. Australische aandelen zijn al 0,9% hoger geopend en futures voor Hong Kong-aandelen wijzen op solide winsten. Er zijn echter nog steeds zorgen, zoals blijkt uit de 47% daling van de First Republic Bank naar een record dieptepunt. Ondanks dit houdt de dollar verliezen vast, omdat de Federal Reserve mogelijk een voorzichtiger beleidsaanpak zal aannemen met betrekking tot rentetarieven als gevolg van de recente financiële onrust, wat speculatie heeft aangewakkerd over een langzamer tempo van verkrapping door belangrijke centrale banken wereldwijd.</p>
<p>Aan de andere kant, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De prijs van de cryptocurrency schommelde maandag rond de $28.000, terwijl investeerders in afwachting waren van de rentebeslissing van de Amerikaanse centrale bank op woensdag. De cryptocurrency was eerder op de dag kortstondig gestegen tot boven de $28.400 na de bekendmaking van de Amerikaanse Federal Reserve dat het ging samenwerken met andere grote centrale banken om een ​​stabiele <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> van Amerikaanse dollars in het wereldwijde financiële systeem.</p>
<p>Rapporten van Ark Invest geven aan dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De recente rally van ‘suggereert dat het zich gedraagt als een ‘veilige haven’-activum, vergelijkbaar met tijdens de bankcrises in de VS en Europa. Ark Invest is van mening dat toezichthouders zich meer hadden moeten richten op de gecentraliseerde en ondoorzichtige faalpunten van het traditionele banksysteem.</p>
<p>Ondertussen onthulde het recente rapport van CoinShares dat beleggingsproducten in digitale activa zes opeenvolgende weken netto uitstroom hebben ervaren, met een totaal van $95 miljoen voor de week die eindigde op 17 maart. In de afgelopen zes weken bedroegen de totale uitstroom $424 miljoen. De gecombineerde uitstroom voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>, Ether en meerdere activa bedroegen $130 miljoen, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> het ontvangen van $35 miljoen aan instromen als gevolg van shortposities op een prijsdaling. Het rapport suggereert dat investeerders mogelijk hebben teruggetrokken uit digitale activa om liquiditeit tijdens de bankencrisis te waarborgen. Echter, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zag instromen van $1.3 miljoen na een uitstroom van $13 miljoen in de afgelopen week.</p>
<h2 id="h2-Onderwerp20van20de20dag20DWF20Labs20verwerft201520miljoen20aan20SNX20waardoor20de20liquiditeit20van20Synthetix20wordt20verhoogd935026"><a name="Onderwerp van de dag: DWF Labs verwerft $15 miljoen aan SNX, waardoor de liquiditeit van Synthetix wordt verhoogd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: DWF Labs verwerft $15 miljoen aan SNX, waardoor de liquiditeit van Synthetix wordt verhoogd</h2><p>Web3 investerings- en kwantitatieve handelsfirma DWF Labs heeft $20 miljoen geïnvesteerd in Synthetix, een platform voor tokenized asset-uitgifte. De investering omvat de verwerving van $15 miljoen aan Synthetix’s inheemse token, SNX, die zal worden gebruikt om de liquiditeit en market-making op gecentraliseerde en gedecentraliseerde beurzen te vergroten. Synthetix stelt gebruikers in staat om real-world assets te tokeniseren in derivaten genaamd Synths, die worden verhandeld met behulp van een pooled collateral model dat fees genereert voor SNX collateral providers.</p>
<p>DWF Labs zal Synthetix’s eeuwigdurende futures integreren in haar handelsactiviteiten en nog eens $5 miljoen aan SNX aanschaffen zodra de integratie is voltooid. Het v2-platform van Synthetix overtrof in maart 2023 een dagelijks handelsvolume van $400 miljoen voor eeuwigdurende swaps.</p>
<p>De samenwerking kan significante implicaties hebben voor zowel Synthetix als zijn governance token, SNX. Ten eerste zou de toegenomen liquiditeit en market-making potentieel de vraag naar SNX kunnen vergroten. Ten tweede zou de integratie van de perpetual futures van Synthetix in de handelsactiviteiten van DWF Labs de adoptie van het Synthetix-platform kunnen vergroten en meer kosten kunnen genereren voor SNX-collateral providers. Ten slotte zou de toewijding van DWF Labs om nog eens $5 miljoen aan SNX te kopen de waarde van de token kunnen verhogen en vertrouwen kunnen geven in de toekomstige groei en succes van het platform.</p>
<p>Over het algemeen kan de samenwerking en investering positief zijn voor Synthetix en SNX, wat de vraag, adoptie en vertrouwen in de toekomst van het platform kan vergroten.</p>
<h2 id="h2-Synthetix20SNX2029789200192020Neutrale20Outlook969997"><a name="Synthetix (SNX) $2.9789 (+0.19%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Synthetix (SNX) $2.9789 (+0.19%) - Neutrale Outlook</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde uurlijkse ondersteuningszone: 2.980 - 2.971</em></strong></li><li><strong><em>Dichtstbijzijnde uurlijkse weerstandszone: 3.022 - 3.051</em></strong></li><li><strong><em>Sleutelniveau: 2,971 (Maandelijks laagste punt van oktober 2020)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1679363513Untitled0321 1.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1679363528Untitled0321 2.png" alt=""></p>
<p>Bij het observeren van SNX op een dagelijkse tijdschaal, wordt het duidelijk dat de munt in totaal 10 keer is afgewezen van het wekelijkse weerstandskanaal sinds 5 maart. Dit suggereert dat de strijd tussen de stieren en beren steeds heviger wordt, hoewel de stieren nog steeds een voordeel hebben omdat ze de prijs van SNX binnen het kanaal kunnen houden. Bij nader inzien van het 4H-tijdsbestek is een symmetrisch driehoekspatroon ontstaan, gevormd door recente hoogte- en dieptepunten. Dit patroon duidt typisch op een aanstaande uitbraak in een van beide richtingen.</p>
<p>Recente candlesticks geven echter aan dat de opwaartse beweging aanzienlijke weerstand heeft ondervonden, terwijl de neerwaartse beweging stabieler is geweest qua momentum. Als SNX er echter in slaagt om te sluiten binnen de aanbodzone tussen 3.088 en 3.201, die werd vastgesteld door de lont van de laatste 4 uur hoge, kunnen de bulls zich richten op het maandelijkse niveau van 3.486.</p>
<p>De munt zal echter waarschijnlijk een hoge volatiliteit ervaren, aangezien het een hogere aanbodzone tussen 3.215 en 3.380 opnieuw test. Omgekeerd, als SNX onder het maandelijkse niveau van 2.971 sluit, kunnen de beren zich concentreren op drie potentiële doelen: 1. tussen 2.841 en 2.826; 2. tussen 2.810 en 2.778; en 3. 2.5395.</p>
<p><strong>Uurlijkse weerstandszones</strong></p>
<ol>
<li>3.022 - 3.051</li><li>3.088 - 3.201</li><li>3.215 - 3.380</li></ol>
<p><strong>Uurlijkse ondersteuningszones</strong></p>
<ol>
<li>2.980 - 2.971</li><li>2.920 - 2.875</li><li>2.841 - 2.778</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 visie 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 vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>