RGFpbHkgTmV3cyB8IEJpdGNvaW4gcGFzc2VlcnQgJDI0SyB0ZXJ3aWpsIG1hY3JvZmFjdG9yZW4gZ3Vuc3RpZyB6aWpuIHZvb3IgY3J5cHRvLCB2b29yc3RlbCB2b29yIExpZG8gREFPJ3MgVHJlYXN1cnkgc3R1d3QgTERPIFRva2VuIG9taG9vZw==

<p><img src="https://gimg2.gateimg.com/blog/166563293266894988220221013-114826.jpeg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting202020Bitcoin2020Stijgt20door20lagere20aandelen20en20obligatievolatiliteit20krimpt20Etheraanbod20sinds20januari821941"><a name="Crypto Dagelijkse Samenvatting:   Bitcoin  Stijgt door lagere aandelen- en obligatievolatiliteit, krimpt Ether-aanbod sinds januari" 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> Stijgt door lagere aandelen- en obligatievolatiliteit, krimpt Ether-aanbod sinds januari</h2><p>Goedemorgen en veel succes, handelaren! Laten we deze donderdag grijpen en er het beste van maken! 🚀</p>
<p>Aziatische aandelenmarkten stegen op donderdag nadat ook de Amerikaanse aandelen omhoog gingen. Dit gebeurde terwijl beleggers nieuwe gegevens overwogen die suggereren dat de Federal Reserve haar beleid verder zal aanscherpen. De gegevens omvatten s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> De detailhandelsverkopen in januari stegen en het vertrouwen van huizenbouwers in februari. Ondanks de veerkracht van de markt en het succes van speculatieve technologieaandelen wordt verwacht dat toekomstige Amerikaanse werkgelegenheidsgegevens een stijging van het aantal werkloosheidsaanvragen zullen onthullen. Jonathan Golub van Credit Suisse gelooft echter dat de VS dit jaar geen recessie zal doormaken.</p>
<p>De futures op aandelen voor Australië, Japan en Hong Kong waren hoger nadat de S&amp;P 500 met 0,3% steeg en de Nasdaq 100 met 0,8% sloot. De benchmark 10-jaars Treasury yields stegen zes basispunten. Bovendien daalden de futures op ruwe olie onder de $79 per vat nadat de EIA meldde dat de ruwe voorraden vorige week met 16 miljoen vaten zijn gestegen.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Steeg voor de tweede opeenvolgende dag naar het hoogste niveau sinds augustus en steeg met 8,7%. Altcoins rallyden ook, omdat de zorgen over de crackdown van Amerikaanse regelgevers afnamen. De SEC stelde nieuwe regels voor om de regulering rondom crypto-custodians aan te scherpen en de omloop van BUSD, de op twee na grootste stabl, te reguleren. <a href="/price/ecoin-ecoin" rel="nofollow noopener noreferrer" target="_blank">Ecoin</a>, afgenomen. De voorraad Ether is sinds januari aan het afnemen, waardoor het netto deflatoir is geworden.</p>
<p>Volgens Acheson, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De 65% daling van in 2022 maakt het een overtuigende liquiditeitsmogelijkheid, met name voor langetermijnbeleggers die BTC beschouwen als een waardeopslag. De recente lagere volatiliteit op de aandelen- en obligatiemarkten, dalende olieprijzen en een verzwakking van de Amerikaanse dollar hebben allemaal bijgedragen aan de groei van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In tegenstelling tot aandelen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> wordt niet beïnvloed door negatief economisch nieuws of hogere rentetarieven omdat het geen contant geld heeft <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flow</a> s te onderscheiden, en het heeft een s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> de begane grond gezien de verschillende gebruiksmogelijkheden. Hoewel andere risicovolle activa gevoelig zijn voor een liquiditeitsherstel, heeft geen enkele zo’n ernstige neergang ervaren als <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<h2 id="h2-Onderwerp20van20de20dag202020Lido20DAO2020De20LDO20stijgt20na20het20voorstel20om2030M20Ether20uit20de20schatkist20te20verkopen20of20te20staken946626"><a name="Onderwerp van de dag:   Lido DAO  De LDO stijgt na het voorstel om $30M Ether uit de schatkist te verkopen of te staken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> De LDO stijgt na het voorstel om $30M Ether uit de schatkist te verkopen of te staken</h2><p>Het recente voorstel ingediend door <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> De financiële tak van ’s, Steakhouse Financial, is gericht op het beslissen of de DAO de 20.304 ether, ter waarde van ongeveer $30 miljoen, die het in zijn schatkist heeft, moet verkopen of inzetten. Het voorstel omvat ook drie andere voorstellen met betrekking tot de schatkist, zoals het diversifiëren van stabl <a href="/price/ecoin-ecoin" rel="nofollow noopener noreferrer" target="_blank">Ecoin</a> het aanhouden en verkopen van protocoloverschotten om operationele kosten te financieren.</p>
<p>Naast dit voorstel, <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> heeft ook een voorstel ingediend voor een Token Reward Plan (TRP) ter goedkeuring. Het plan omvat een kader om stemmende LDO-tokens over een periode van maximaal vier jaar te verspreiden onder DAO-bijdragers, en de bevoegdheid om maximaal 22 miljoen LDO te schenken aan een subsidiesvereniging voor gebruik in het TRP.</p>
<p>Het voorstel en het TRP-plan hebben geleid tot een positieve reactie van investeerders, aangezien de LDO-token 10% heeft gewonnen op de dag na de indiening van het voorstel en 18% de volgende dag, voordat hij zich rond een winst van 10% stabiliseerde. De rally is een voortzetting van de positieve prestaties van de token in de afgelopen maand, waarin het ongeveer 30% heeft gewonnen.</p>
<p><a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> Het succes van Gate.io blijkt uit het feit dat het de hoogste totale waarde heeft vergrendeld onder alle gedecentraliseerde financiële protocollen, waarbij populaire protocollen zoals MakerDAO en Curve Finance worden overtroffen. Het platform heeft meer dan $8,4 miljard aan gestake ether, wat wijst op een aanzienlijk niveau van vertrouwen en vertrouwen in het stakingssysteem.</p>
<p><a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> is een gedecentraliseerde autonome organisatie die een liquide stakingssysteem biedt voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. Staking is het proces waarbij een bepaalde hoeveelheid cryptocurrency wordt vergrendeld om bij te dragen aan de beveiliging van de blockchain en beloningen te verdienen. <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> stelt gebruikers in staat om hun te staken <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> in andere protocollen en verdien staking beloningen zonder de controle over hun activa op te geven, wat bekend staat als non-custodial staking.</p>
<h2 id="h2-Lido20DAO2020LDO2028731200972020Bullish20Outlook981226"><a name="Lido DAO  (LDO) $2.8731 (+0.97%) - Bullish Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a> (LDO) $2.8731 (+0.97%) - Bullish Outlook</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 2.716 - 2.631</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszône: 3.000 - 3.096</em></strong></li><li><strong><em>Sleutelniveau: 3.100 (Maandelijks laagste punt van oktober 2021)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1676512690Untitled0216.png" alt=""></p>
<p>Naar aanleiding van haar bestuursvoorstel steeg LDO met 18% binnen twee dagen en brak door een eerdere aanbodzone, wat bevestigt dat het nu in een bullish trend zit en de stijging waarschijnlijk zal voortzetten. Dit is verder bevestigd door de Ichimoku Cloud-indicator, aangezien de prijsactie boven de blauwe wolk handelt. Op basis van de Fibonacci-verlengingstool wordt verwacht dat LDO het niveau van 1,618% (3,393) zal testen als het in staat is om succesvol uit te breken boven de huidige aanbodzone (2,716 - 3,096). LDO heeft echter een s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> Een dalende kaars onder de oplopende wigpatroon op het dagelijkse tijdsbestek zou het patroon volledig ongeldig maken, wat normaal gesproken een omkeerpatroon is. Over het algemeen zijn de vooruitzichten momenteel gunstig voor de stieren, vooral gezien de bullish engulfing candle die op 14 februari werd gespot en de daaropvolgende stijging die wijst op uitstekende kracht.</p>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>3.000 - 3.096</li><li>3.222 - 3.393</li><li>3.684 - 3.970</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>2.716 - 2.631</li><li>2.460 - 2.286</li><li>2.104 - 1.947</li></ol>
<div class="blog-details-info"><br><div>Auteur: <strong>Peter L.</strong>, Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 gevallen zullen juridische stappen worden ondernomen wegens auteursrechtschending.<br></div><p></p><br></div></div></div>