TWFya3R0cmVuZCB8IERlIFNFQyBzdGFwdCBuYWFyIFRlcnJhZm9ybSBMYWJzLCBoZXQgYmVkcmlqZiBhY2h0ZXIgZGUgbWlzbHVrdGUgVGVycmEgU3RhYmxlY29pbjsgU0JGIG9wIGJvcmd0b2NodCB0ZXJ3aWpsICdoZXJyb2VwaW5ncycgcHJvY2VkdXJlcyBlZW4gbW9nZWxpamtoZWlkIGJsaWp2ZW4=

2023-02-17, 05:45

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>Gedurende de afgelopen week is de cryptocurrency markt getuige geweest van een opmerkelijke stijging, waarbij de totale marktkapitalisatie steeg tot $1.8B, een daling van $600M ten opzichte van de vorige week. Met de afgelopen week die een marktbrede correctie leek te bedreigen, lijkt het erop dat deze zorgen zijn afgenomen, waarbij activa over de top 100 beginnen te versnellen in prijs en volume, waarbij velen stijgingen van meer dan 10% zien. Echter, ondanks deze positieve prijsmomentum, is de markt gehinderd door discussies over institutionele tekortkomingen, waaronder de <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> stablecoin en Sam Bankman-Fried. Met de bevestiging van de SEC dat ze Terraform Labs aanpakken en ze aanklagen, de rechter die toezicht houdt op de zaak van SBF die sterkere beperkingen voorstelt, en de controverse rond historische Binance-overdrachten, is de institutionele kant van de markt deze week gehuld in controverse.</p>
<h2 id="h2-Het20laatste20nieuws244827"><a name="Het laatste nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het laatste nieuws</h2><h3 id="h3-De20SEC20wil20Terraform20Labs20het20bedrijf20achter20de20mislukte2020voor20de20rechter20slepen202020Terra2020stablecoin474484"><a name="De SEC wil Terraform Labs, het bedrijf achter de mislukte , voor de rechter slepen.   Terra  stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De SEC wil Terraform Labs, het bedrijf achter de mislukte , voor de rechter slepen. <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> stablecoin</h3><p>Na de verwoestende crash van de TerraUSD (UST) token bijna een jaar geleden, heeft de SEC zich verplaatst om het moederbedrijf, Terraform Labs, te vervolgen. Met naar verluidt een ‘formidabele uitdaging’ voor Do Kwon en andere bedrijfsleiders, heeft de SEC bevestigd dat zij het bedrijf onderzoeken en aanklachten indienen in verband met ‘het orkestreren van een multi-miljard dollar crypto-activa-effectenfraude’ via de algoritmische stablecoin.</p>
<p>In een eerder deze week uitgebrachte persverklaring werd ook bevestigd dat de SEC onderzoekt. <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Het vlaggenschipproduct van Gate.io, Anchor, bood een consistente rente van 20% op de UST stablecoin. Op het hoogtepunt van het succes van UST had Anchor toegang tot verschillende miljarden dollars aan liquiditeit.</p>
<h3 id="h3-Binance20heeft2040020miljoen20overgeboekt20van20Amerikaanse20partner20naar20Zhaogeleide20firma593091"><a name="Binance heeft $400 miljoen overgeboekt van Amerikaanse partner naar Zhao-geleide firma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance heeft $400 miljoen overgeboekt van Amerikaanse partner naar Zhao-geleide firma</h3><p>In een recent rapport van Reuters werd onthuld dat Binance had <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> toegang tot een bankrekening die eigendom is van zijn Amerikaanse partner en dat ze meer dan $400 miljoen hebben overgeboekt van deze rekening naar die van een handelsfirma die wordt beheerd door de CEO, Changpeng Zhao. Deze transacties zouden hebben plaatsgevonden gedurende het eerste kwartaal van 2021, waarbij het geld is verplaatst van de Binance US-rekening bij Silvergate Bank naar de handelsfirma Merit Peak Ltd, volgens Reuters die bankgegevens en correspondentie van het bedrijf heeft aangehaald.</p>
<p>Binance US reageerde echter snel op dit rapport met een verklaring van woordvoerder Kimberl Soward, waarin werd gesteld dat Reuters ‘verouderde informatie’ rapporteerde. Echter, tot nu toe hebben moederbedrijf Binance, Changpeng Zhao, en Prime Trust (een bewaarbedrijf dat naar verluidt klantengelden voor de Amerikaanse beurs aanhoudt) nog geen officiële reactie vrijgegeven.</p>
<h3 id="h3-SBF20Out20On20Bond20As20Revocation20Proceedings20Remain20A20Possibility257342"><a name="SBF Out On Bond As ‘Revocation’ Proceedings Remain A Possibility" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SBF Out On Bond As ‘Revocation’ Proceedings Remain A Possibility</h3><p>Sam Bankman-Fried blijft momenteel op borgtocht, maar de federale rechter in New York, Lewis Kaplan, die zijn strafzaak wegens fraude behandelt, heeft verklaard dat dit zou kunnen veranderen als SBF blijft volharden in het overtreden van zijn borgtochtvoorwaarden die door de rechtbank zijn vastgesteld. Eerder deze week correspondeerden federale aanklagers met de rechtbank en beweerden dat SBF een eerdere gerechtelijke uitspraak had overtreden door versleutelde technologie te gebruiken toen hij een virtueel privénetwerk (VPN) gebruikte om naar de Super Bowl te kijken. De aanklagers drongen er bij de rechtbank op aan om strengere voorwaarden op te leggen, waarbij SBF geen toegang heeft tot apparaten die verbonden zijn met internet, tenzij het gerelateerd is aan de zaak.</p>
<p>Tijdens een bijeenkomst op donderdag om dit te bespreken, verzette de advocaat van SBF, Mark Cohen, zich fel tegen deze maatregelen en noemde ze ‘draconisch’. Hij betoogde dat SBF internettoegang nodig heeft voor specifieke toepassingen, waaronder Google Docs, om zich voor te bereiden op zijn aanstaande proces. Echter, rechter Lewis Kaplan was het hier niet mee eens en suggereerde zelfs dat de voorgestelde maatregelen van de overheid mogelijk niet effectief zijn om ervoor te zorgen dat SBF zich niet met de zaak bemoeit of zijn borgtochtvoorwaarden verder overtreedt.<br><img src="https://gimg2.gateimg.com/image/article/167661252911.png" alt=""><br>Sam Bankman-Fried (Afbeelding met dank aan CoinPri)</p>
<h2 id="h2-Huidige20projecttrends739818"><a name="Huidige projecttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige projecttrends</h2><p>Op basis van gegevens verstrekt door CoinMarketCap hebben de meeste van de top-winstgevende projecten van de afgelopen week zich gericht op het creëren van een duurzame infrastructuur voor de wereldwijde digitale token-economie en het mogelijk maken van naadloze transacties tussen elke partij over meerdere markten op internationale schaal. De meeste van deze projecten hebben wekelijkse prijswinsten gezien tot wel 200%. Dit is waarschijnlijk te wijten aan de groeiende discussies over adoptie en het nut van digitale tokens, wat heeft geleid tot de behoefte aan een stabiele en efficiënte infrastructuur voor tokenoverdrachten en -distributie.</p>
<h2 id="h2-De20huidige20BTCtrend329504"><a name="De huidige BTC-trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige BTC-trend</h2><p><img src="https://gimg2.gateimg.com/image/article/167661259322.png" alt=""><br>Wekelijks <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">btc prijs</a> Gegevens (Gegevens met dank aan Blockchain.com)</p>
<p>Afgelopen week, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is begonnen met het herstellen en is met 8,67% gestegen. Na te zijn ontsnapt aan de progressieve prijsdaling van vorige week, handelde BTC aanvankelijk horizontaal op een gemiddelde van $21,83k terwijl het balanceerde op de rand van zijn 7-daagse SMA. Op de 15e brak BTC echter eindelijk uit deze stagnatie en begon scherp te stijgen door de $22k grens heen richting $24k. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bereikte een wekelijks hoogtepunt van $24,993 op de avond van de 15e, wat erop wijst dat het activum sterk blijft ondanks gemengde marktsentimenten die vorige week ontstonden toen een correctie leek te verhinderen dat de top 100 activa.</p>
<p>De huidige prijsontwikkeling van BTC lijkt erop te wijzen dat het actief zich losmaakt van de bearishness van de vorige week, wat mogelijk het gevolg is van het begin van het herstel van de internationale macro-economische markten en een matige verlichting van de inflatie wereldwijd. Gezien BTC erin slaagde om deze week een maandelijks hoogtepunt te bereiken, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> handelt op een progressief opwaartse koers, wat de markt kan stimuleren en op de lange termijn tot een bull run kan leiden.</p>
<p>Gezien deze groeiende bullish sentiment, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> MVRV (marktwaarde ten opzichte van gerealiseerde waarde) van BTC is begonnen met herstellen na een daling in de afgelopen weken. Aan het begin van de week stond BTC’s MVRV op een bescheiden 1,103, maar begon al snel te dalen met een licht stijgende trend, en bereikte op de 16e het hoogste niveau tot nu toe in 2023, namelijk 1,242. Dit geeft aan dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blijft standhouden boven $20.000 en beweegt zich weg van de marktbodemindicatie die de grafieken al enkele maanden achtervolgt.<br><img src="https://gimg2.gateimg.com/image/article/167661263733.png" alt=""><br>Wekelijkse BTC MVRV-gegevens (Gegevens met dank aan Blockchain.com)</p>
<h3 id="h3-De20staat20van20ETHgasvergoedingen729477"><a name="De staat van ETH-gasvergoedingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De staat van ETH-gasvergoedingen</h3><p>Vanaf 9 februari is er een matige toename geweest in het totale volume gas dat in de afgelopen week is gebruikt in vergelijking met de vorige week, waarbij het laagste cijfer werd bereikt op de 15e, met een totaal van 107.997.105.063. Het hoogste cijfer van deze week werd bereikt op de 12e, met een totaal van 108.568.582.883, wat een vergelijkbaar totaal gebruik laat zien als in het begin van 2023. Deze terugval naar het gebied van 107B is indicatief voor een geleidelijk dalende trend van gasgebruik in de afgelopen maand.</p>
<p>Als gevolg hiervan, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De grenzen van de gasvergoeding zijn deze week aanzienlijk gestegen ten opzichte van de vorige week. De lage gasgrenzen lagen tussen 11-814 gwei, de gemiddelde grenzen lagen tussen 11-814 gwei en de hoge grenzen lagen tussen 11-815 gwei - wat wijst op een aanzienlijk verschil in gasvergoedingen gedurende de afgelopen week.</p>
<p>In de afgelopen 24 uur waren de top ‘Gas Guzzlers’ volgens Etherscan: <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>: Universal Router (met kosten van in totaal $ 765,756.45 of 463.40 ETH), Seaport 1.1 (met kosten van in totaal $ 344,783.88 of 208.65 ETH), en <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V2: Router 2 (met totale kosten van $320,570.04 of 193.99 ETH) - wat een opmerkelijke stijging laat zien ten opzichte van de vorige week.</p>
<p>De geschatte kosten van transacties via platforms zoals OpenSea: Sale, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V3: Swap en USDT: Transfer is voorgesteld om tussen $2,42 en $9,15 te zijn, volgens Etherscan.</p>
<h2 id="h2-De20huidige20macrosituatie302607"><a name="De huidige macro-situatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige macro-situatie</h2><h3 id="h3-ECB20Economic20Bulletin20werpt20een20sombere20economische20toekomst20op20voor20het20eurogebied31653"><a name="ECB Economic Bulletin werpt een sombere economische toekomst op voor het eurogebied" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ECB Economic Bulletin werpt een sombere economische toekomst op voor het eurogebied</h3><p>In een artikel van het Economisch Bulletin dat op donderdag is gepubliceerd, heeft de Europese Centrale Bank (ECB) belangrijke updates geboden over de economische toekomst voor Europa. Er werd gemeld dat de toekomstige rentebeslissingen van de Raad van Bestuur zouden blijven afhangen van de gegevens en een vergadering-voor-vergadering aanpak zouden volgen.</p>
<p>Bovendien werd gemeld dat enquêtegegevens wijzen op een verzwakking van de wereldwijde economische activiteit aan het begin van het jaar en dat de prijsdruk hoog blijft als gevolg van de gevolgen van hoge energiekosten. Aan de andere kant is echter opgemerkt dat de lonen sneller groeien als gevolg van robuuste arbeidsmarkten.</p>
<h2 id="h2-Wat20zou20er20kunnen20komen20in20de20komende20week689868"><a name="Wat zou er kunnen komen in de komende week?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zou er kunnen komen in de komende week?</h2><p>Met de markt die een positievere stemming heeft gekregen, is het waarschijnlijk dat de markt de komende dagen progressief zal blijven groeien. Echter, met meer bearish nieuws dat naar buiten is gekomen, zou deze positiviteit kunnen leiden tot een meer bearish sentiment onder investeerders in de hele markt. Aldus kan de marktherstel afhankelijk zijn van de overkoepelende sentiment binnen de bredere gemeenschap.</p>
<div class="blog-details-info"><br><div>Auteur: Gate.io Onderzoeker: <strong>Matthew Webster-Dowsing</strong><br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 vermeld. In alle andere gevallen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>