RGFnZWxpamtzIG5pZXV3cyB8IFZlcmtsYXJpbmcgdmFuIEZlZC12b29yeml0dGVyIFBvd2VsbCBzdGFhdCBjZW50cmFhbCB0ZXJ3aWpsIG1hcmt0ZW4gd2FjaHRlbiwgR2VuZXNpcyBiZXJlaWt0ZSBoZXJzdHJ1Y3R1cmVyaW5nc2RlYWwgbWV0IERDRywgZFlkWCB2ZXJsZW5ndCBsb2NrLXVwIHBlcmlvZGU=

2023-02-07, 02:02

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Markten20stijgen20lichtjes20voorafgaand20aan20de20verklaring20van20Fedvoorzitter20Powell20olie20en20goud20blijven20worstelen664497"><a name="Crypto Dagelijks Overzicht: Markten stijgen lichtjes voorafgaand aan de verklaring van Fed-voorzitter Powell, olie en goud blijven worstelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Markten stijgen lichtjes voorafgaand aan de verklaring van Fed-voorzitter Powell, olie en goud blijven worstelen</h2><p>Goedemorgen, handelaren. Het is dinsdag en zoals altijd, laten we er genadeloos voor gaan. 🚀</p>
<p>Aziatische aandelen en Amerikaanse aandelenfutures laten een bescheiden groei zien, terwijl beleggers wachten op de verklaring van Fed-voorzitter Powell, die om 17:40 UTC wordt verwacht. Obligaties van de Treasury en Australische obligaties ondergaan veranderingen in het licht van de verwachte opmerkingen van Powell over toekomstige renteverlagingen. Een strateeg van JPMorgan Chase heeft echter geadviseerd om niet deel te nemen aan de door de Fed gedreven aandelenrally van vorige week, omdat zij van mening zijn dat de huidige deflatoire trend in de Amerikaanse economie mogelijk tijdelijk is.</p>
<p>Wat betreft FX en commodities, blijft de Japanse yen stabiel na winsten in de <a href="https://www.gate.io/trade/USD_USDT" target="_blank">Amerikaanse dollar</a> Nu Japan een onverwachte stijging van de nominale lonen in december zag, de grootste toename in bijna 26 jaar, gelooft de markt dat de centrale bank haar stimuleringsprogramma onder de nieuwe gouverneur kan aanpassen of terugtrekken. Ondertussen is de oliemarkt licht gestegen na een daling van bijna 9% sinds 23 januari, terwijl goud sinds gisteren in wezen onveranderd is gebleven, maar nog steeds 5% lager is dan zijn weekendhoogte van $ 1.960.</p>
<p>Op Crypto, zowel de cryptocurrency als de aandelenmarkten hadden een slechte start van de week met dalende prijzen. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> werd verhandeld op $22,810 met een daling van 1.1%. De reden voor de daling van de cryptoprijzen was het sterke banenrapport van de VS, dat parallel loopt met de intentie van de Fed om de inflatie te verlagen.</p>
<p>Andere cryptocurrencies zoals Ether, BNB, <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> en SOL zagen ook een afname. Naarmate de Nasdaq en S&amp;P 500 daalden, daalden ook de aandelen van Coinbase met 4,6% en Silvergate met 8%. Grayscale’s <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> vertrouwen GBTC had een grotere korting en sloot de week af met een 42% korting in vergelijking met de waarde van de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> het houdt.</p>
<p>Genesis Global trekt de aandacht in de wereld van crypto door een principeovereenkomst te bereiken met Digital Currency Group (DCG) en zijn schuldeisers om zijn activiteiten te herstructureren.</p>
<p>Het herstructureringsplan omvat de verkoop van de crypto-handels- en market-making-tak van Genesis. Als onderdeel van de overeenkomst zal DCG zijn belang in Genesis Global Trading overdragen aan Genesis Global Holdco, de houdstermaatschappij van Genesis, en ook zijn bestaande leningen herfinancieren. Zowel Genesis als DCG-schuldeisers kunnen verwachten 80% van hun fondsen terug te krijgen, met de mogelijkheid om 100% te bereiken. De daadwerkelijke herstelpercentage is afhankelijk van de converteerbare preferente aandelen, de resultaten van het liquideren van activa en de kosten die gepaard gaan met de lopende faillissementsprocedure.</p>
<p>Genesis ondergaat hoofdstuk 11 faillissement als gevolg van een liquiditeitscrisis veroorzaakt door het faillissement van crypto exchange FTX.</p>
<h2 id="h2-Onderwerp20van20de20dag20dYdX20Tokenomics2020Een20spel20van20afwachten20en20zien427265"><a name="Onderwerp van de dag: dYdX Tokenomics - Een spel van afwachten en zien" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> Tokenomics - Een spel van afwachten en zien</h2><p>Het lijkt erop dat dYdX Foundation, het team achter de populaire gedecentraliseerde crypto-uitwisseling, van gedachten is veranderd - of beter gezegd, een verandering in tokenomics heeft doorgemaakt. Ze hebben onlangs enkele “aanpassingen” aangekondigd in hun tokenverdelingsstrategie. In plaats van vroege investeerderstokens vrij te geven op 1 februari, worden ze nu vergrendeld tot 1 december 2023. Deze stap heeft nogal wat opschudding veroorzaakt in de cryptowereld, aangezien sommigen dit zagen als een teken van vertrouwen in het langetermijnsucces van het project, terwijl anderen teleurgesteld waren door de vertraagde tokenvoorziening.</p>
<p>Maar wat zou deze plotselinge verandering van plannen kunnen hebben veroorzaakt? Sommigen zeggen dat de recente hardhandige aanpak door de SEC van handhavingsacties dYdX misschien heeft afgeschrikt om een hartig woordje te wisselen met hun advocaten. En zoals we allemaal weten, kunnen advocaten echte spelbrekers zijn. Maar, in alle ernst, de vraag blijft: waarom zouden vroege investeerders instemmen met een langere lock-up periode? Het antwoord is eenvoudig: ze willen voldoen aan de Amerikaanse effectenwetgeving.</p>
<p>In het land van de vrijheid moeten alle effecten ofwel geregistreerd, vrijgesteld of illegaal zijn. En als je je bijzonder patriottisch voelt, moet je ook bepaalde regels volgen om niet als ‘onderhandelaar’ te worden beschouwd. Een van deze regels is Securities Act Rule 144, die een bewaartermijn van één jaar vereist voor alle verkopen, zowel van gelieerde als niet-gelieerde partijen, om aan te tonen dat de effecten zijn gekocht met ‘investeringsintentie’.</p>
<p>Dus wilden de dYdX-investeerders die instemden met de verandering van tokenomics misschien hun vertrouwen in het project aangeven door hun toegang tot de tokens uit te stellen. Of misschien wilden ze hun toewijding aan de Amerikaanse wetten tonen en langzaam naar naleving toe werken. Hoe dan ook, het zal fascinerend zijn om te zien welke andere maatregelen dYdX neemt met betrekking tot tokenemissies in de toekomst.</p>
<h2 id="h2-dYdX20DYDX2029513201732020Neutrale20Vooruitzichten111577"><a name="dYdX (DYDX) $2.9513 (+1.73%) - Neutrale Vooruitzichten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>dYdX (DYDX) $2.9513 (+1.73%) - Neutrale Vooruitzichten</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 2.088 - 2.616</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszones: 2.944 - 3.088</em></strong></li><li><strong><em>Key Level: 3.088 (Maandelijks dieptepunt van apr. 2022)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1675735281Untitled0207.png" alt=""></p>
<p>De huidige prijsactie volgt de analyse van vorige week (2 februari) en de huidige terugval lijkt nog wat ruimte te hebben om te dalen. Na twee succesvolle uitbraken op respectievelijk 25 en 31 januari is dYdX met 21% gedaald vanaf zijn hoogtepunt van 3,673. De lont van de candlestick van de dag ervoor geeft aan dat kopers sterk reageren op het 50% Fibonacci retracement niveau. Er is echter een goede kans dat dYdX verder zal terugtrekken naar het 61,8% niveau (2,616) voordat de prijsactie stabiliseert en in een consolidatiefase terechtkomt.</p>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>2.944 - 3.088</li><li>3.108 - 3.426</li><li>3.465 - 3.684</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>2.088 - 2.616</li><li>2.545 - 2.449</li><li>2.143 - 2.031</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 enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>