RGFnZWxpamtzIG5pZXV3cyB8IEluc3RlbGxpbmdlbiB2b29yc3BlbGxlbiA2IGJlbGFuZ3JpamtlIHRyZW5kcyBpbiBjcnlwdG8gaW4gMjAyNDsgemFsIEJUQyBzdGlqZ2VuIHRvdCAkMTYwLjAwMD8gU09MIG92ZXJ0cm9mIFhSUCBvbSBkZSA1ZSBncm9vdHN0ZSBjcnlwdG8gdGUgd29yZGVuIHF1YSBtYXJrdGthcGl0YWxpc2F0aWU=

2023-12-21, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/17031393911_15.png" alt=""><a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash crypto</a><br>Op woensdag heeft de Amerikaanse rechtbank volgens The Block de definitieve goedkeuring gegeven om formeel 69370 in beslag te nemen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en andere cryptocurrencies gerelateerd aan de Silk Road dark web markt. Het vonnis werd voor het eerst uitgesproken in augustus, maar volgens een document van het Hof van Beroep voor het negende circuit van de Verenigde Staten zal het nu van kracht worden. De op woensdag ingediende documenten vermeldden Ross Ulbricht, de oprichter van de Silk Road, als de beklaagde, en twee eisers en de Amerikaanse regering als eisers.</p>
<p>Pantera Capital-partner Paul Veradettakit heeft zes belangrijke voorspellingen voor de crypto-industrie in 2024 vrijgegeven, waaronder:</p>
<ol>
<li>De heropleving van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en DeFi Zomer 2.0;</li><li>Op tokens gebaseerde sociale ervaring voor nieuwe gebruiksscenario’s voor consumenten;</li><li>Toename van TradFi DeFi-bruggen zoals stablecoins en spiegelactiva;</li><li>De integratie van modulaire blockchain en zero-knowledge proof;<br>5.Er worden meer rekenintensieve toepassingen, zoals AI en DePIN, op de keten gelanceerd;<br>6.De integratie van het ecosysteem van de publieke keten en het “centrale stralingsmodel” van de applicatieketen.</li></ol>
<p>Gegevens tonen aan dat <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> heeft vervangen <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> als de op vier na grootste cryptocurrency naar marktwaarde, met een marktwaarde van $35,1 miljard, en bereikte een nieuw 20-maands hoogtepunt. Deze week, gedreven door stijgende activaprijzen en voortdurende instromen van DeFi-protocollen, overtrof de Totale Waarde Geblokkeerd (TVL) van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> voor het eerst sinds de FTX-crash in november vorig jaar $1 miljard.</p>
<p>Het handelsvolume van DEX op Solana is toegenomen. Op 15 december bereikte de transactievolume van Orca $746 miljoen, wat $100 miljoen overtrof vóór november. De meerderheid van de toename in activiteiten kan worden toegeschreven aan MEME-tokens zoals Bonk, die momenteel een marktwaarde hebben van meer dan $1,2 miljard. De huidige handelsprijs van SOL is $83,58, met een stijging van 12,14% in 24 uur.</p>
<p>Eerder werd gemeld dat de dagelijkse handelsvolume van Solana Ecological DEX meer dan $1,2 miljard bedroeg, wat de tweede keer in de geschiedenis is dat het dit bedrag heeft overschreden. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>; Later werd gemeld dat het handelsvolume van SOL op Upbit gedurende 55 opeenvolgende dagen hoger was dan het handelsvolume van ETH.</p>
<p>In de afgelopen weken is 95% van de handelsactiviteiten op de EVM-keten gegenereerd via inschrijvingen.</p>
<p>Etherscan tweette dat sinds medio november frequent inies zijn gemaakt op de EVM-keten, wat heeft geleid tot een aanzienlijke stijging van het dagelijkse handelsvolume, stijgende gasvergoedingen en langere verwerkingstijden van transacties. Tot op zekere hoogte kan het fenomeen van inies worden gezien als een goede stresstest voor blockchain- en infrastructuurproviders om hun beperkingen te ueren.</p>
<p>Naarmate de markt geleidelijk verbetert, rennen instellingen ook om de markt te voorspellen. Matrixport heeft het nieuwste rapport vrijgegeven waarin wordt gesteld dat het inflatiepercentage in de VS naar verwachting tegen 2024 zal dalen tot 2%. De macro-economie wordt verwacht de prijs van Bitcoin te ondersteunen om in 2024 een hoger niveau te bereiken. Bitcoin miners beperken vaak het aanbod van nieuwe Bitcoin voor en na de halveringscyclus, en Bitcoin zal zes maanden na de halvering een historisch hoogtepunt bereiken (verwacht in april volgend jaar).</p>
<p>De financieringsrente van Bitcoin blijft hoog, wat aangeeft dat handelaren verwachten dat de prijzen zullen stijgen, en hoewel de volatiliteit van SP500 is gedaald naar meerjarige dieptepunten, blijft de geïmpliceerde volatiliteit hoog. Het is daarom te verwachten dat de financieringsrente tijdens de kerstvakantie zal dalen, maar de volatiliteit kan nog steeds toenemen omdat handelaren zich indekken tegen mogelijke goedkeuringen van Bitcoin-spot-ETF’s.</p>
<p>Volgens de analyse van het rapport is Bitcoin sinds 8 december in een zijwaartse consolidatiezone. Vanwege de verwachte goedkeuring van Bitcoin spot ETF’s begin januari 2024 wordt verwacht dat het lagere ondersteuningsniveau in dit bereik ($40.000) onveranderd zal blijven. Tegelijkertijd blijft het rapport voorzichtig over de vraag of Bitcoin hogere niveaus kan doorbreken tijdens Kerstmis.</p>
<p>Vanuit historisch perspectief is Bitcoin met 3% gestegen van 24 december tot 31 december, maar het rendement is beïnvloed door de sterke rendementen van Bitcoin in de beginjaren, terwijl de prijs van Bitcoin in de afgelopen vijf jaar vier jaar lager is geweest. Dit betekent dat we mogelijk al het hoogtepunt van dit jaar hebben gezien, en de prijzen kunnen blijven consolideren tot het einde van het jaar.</p>
<p>De marktwaarde van Bitcoin is gestegen van $320 miljard naar $827 miljard, en het vermogen van Bitcoin-bezitters is met ongeveer $500 miljard gestegen. Op 31 oktober 2017, toen CME Group de lancering van Bitcoin-futures voor het vierde kwartaal aankondigde, werden CBOE Bitcoin-futures genoteerd op 10 december en CME op 17 december. Vanaf de aankondiging tot de lancering is Bitcoin met +212% gestegen. Wanneer Bitcoin spot ETF’s worden goedgekeurd, kunnen zich vergelijkbare situaties voordoen. De meest waarschijnlijke goedkeuringsdata zijn 8, 9 en 10 januari.</p>
<p>Gezien de frequente bijeenkomsten tussen de SEC, vooral BlackRock, is de verwachting dat Bitcoin spot ETF’s in januari worden goedgekeurd toegenomen. Tolig, sinds 8 december, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De snelheid van het slaan van stablecoin van is vertraagd - wat aangeeft dat institutionele fondsen die van fiatgeld naar cryptocurrency stromen mogelijk wachten op nieuwe vraag begin januari.</p>
<p>Het rapport vermeldt ook dat de TVL, die aan het begin van 2023 $38 miljard bedroeg, nu is gestegen naar $51 miljard, het hoogste niveau vóór de FTX-crash. Met beloftes als een belangrijk waardevoorstel voor <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is de TVL van Lido aanzienlijk toegenomen. De TVL van Lido is gestegen van $6 miljard naar $20 miljard. Over het geheel genomen was de prestatie van DeFi in 2023 echter teleurstellend. De jaarlijkse transactie van dit jaar moet Grayscale Bitcoin Trust (GBTC) zijn, aangezien de korting is verlaagd van -47% naar slechts -8%. Hoewel de Bitcoin-prijzen met +154% zijn gestegen, is de GBTC met +326% gestegen.</p>
<p>Op 21 december verklaarden analisten van CryptoQuant ook in een rapport dat de verwachte vraag naar Bitcoin vanuit meerdere Amerikaanse spot-ETF’s, aanstaande halvering en groei op de bredere aandelenmarkt onder de achtergrond van renteverlagingen Bitcoin kunnen opdrijven naar een hoogtepunt van $160.000. Ondertussen zeggen analisten dat er mogelijk een bullmarkt begint in 2024.</p>
<h2 id="h2-De20belangrijkste20trends20van20vandaag20in20tokens338486"><a name="De belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC149610"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1703139637BTC.png" alt=""><br>Op de 4-uur grafiek raakte het ondersteuningsniveau van $40.280 aan en stabiliseerde, waardoor een opwaartse trend zichtbaar werd. Op korte termijn vormt zich een W-vormig patroon en wordt geprobeerd om door de weerstand te breken. Let op de convergentie van de mid-termijnstructuur op hogere niveaus. Maak gebruik van het algehele opwaartse kanaal voor zowel long- als shortposities. Weerstandsniveaus om op te letten: $45.345 en $47.990; Ondersteuningsniveaus om te behouden: $40.280 en $38.399.</p>
<h3 id="h3-ETH15404"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1703139670ETH.png" alt=""><br>Deze week blijft Ethereum schommelen boven $2.135. Pogingen om de trendlijn te doorbreken zijn niet gelukt, wat heeft geleid tot voortdurend testen eronder. Op korte termijn is het raadzaam om stabiliteit boven $2.135 te behouden. Ondersteuningsniveaus hieronder zijn $2.037 en $1.974. Let op het doorbreken van de weerstand op $2.381; een succesvolle doorbraak kan leiden tot $2.489. Op middellange termijn let op de dalende trend aangegeven door de oranje lijn.</p>
<h3 id="h3-TRB243846"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1703139702TRB.png" alt=""><br>De marktmanipulatiestrategie is duidelijk, met snelle bewegingen binnen vijf minuten. TRB wordt niet aanbevolen voor handel op de termijnmarkt vanwege frequente dalingen variërend van 33% tot 35%. Na een korte termijnbeweging, sluitend op $185, wordt voorgesteld posities te handhaven en een terugtrekking boven de trendlijn te verwachten. Ondersteuning ligt op $108,77, en de langetermijntrends blijven bullish met doelen op $231,25 en $245.</p>
<h2 id="h2-Macro20De20Amerikaanse20aandelenmarkt20heeft20zijn20negen20opeenvolgende20winsten20beindigd20en20Huck20van20de20Fed20verklaarde20dat20de20Fed20van20plan20is20de20rente20te20verlagen20maar20niet20zo20snel553569"><a name="Macro: De Amerikaanse aandelenmarkt heeft zijn negen opeenvolgende winsten beëindigd en Huck van de Fed verklaarde dat de Fed van plan is de rente te verlagen, maar niet zo snel." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Amerikaanse aandelenmarkt heeft zijn negen opeenvolgende winsten beëindigd en Huck van de Fed verklaarde dat de Fed van plan is de rente te verlagen, maar niet zo snel.</h2><p>Op woensdag bleef de Amerikaanse dollarindex sterk boven het niveau van 102, steeg naar een intradayhoogtepunt van 102,54 en sloot uiteindelijk 0,3% hoger op 102,44. Het rendement op Amerikaanse staatsobligaties is gedaald, waarbij het rendement van 10 jaar onder de 3,9% is gedaald en uiteindelijk sloot op 3,853%; Het rendement van de tweejarige Amerikaanse staatsobligatie, die gevoeliger is voor de rentetarieven van de Federal Reserve, sloot op 4,340%.</p>
<p>Spotgoud slaagde er niet in om boven het niveau van $2.040 te stabiliseren en viel kort onder het niveau van $2.030 tijdens de Amerikaanse markt. Uiteindelijk sloot het met een daling van 0,44% op $2.031,24 per ounce; Spotzilver vertoonde een achtbaan trend, met een aanzienlijke stijging tijdens de Amerikaanse markt, gevolgd door een terugtrekking van het grootste deel van de winsten, uiteindelijk sloot het met een stijging van 0,4% op $24,15 per ounce.</p>
<p>Vanwege een onverwachte stijging van de Amerikaanse voorraden ruwe olie vorige week, een grotere dan verwachte stijging van de voorraden brandstof en recordbrekende olieproductie, heeft internationale ruwe olie een terugval ervaren. WTI ruwe olie heeft tijdens de Amerikaanse sessie al zijn winsten teruggenomen en is uiteindelijk met 0,53% gedaald tot $ 73,74 per vat; Brent ruwe olie raakte kort de $ 80-grens tijdens de handelssessie, maar slaagde er niet in om stabiel te blijven en sloot uiteindelijk met 0,24% lager op $ 79,11 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices bleven dalen in de late handel, waarbij de Dow Jones Industrial Average met 1,27% daalde en de Nasdaq met 1,5% daalde. Alle negen opeenvolgende dagen van winst werden beëindigd en de S&amp;P 500-index sloot met 1,47% lager, wat de grootste dagelijkse daling in bijna drie maanden markeerde.</p>
<p>Functionarissen van de Fed hebben opnieuw verklaringen afgelegd. Op woensdag verklaarde voorzitter van de Philadelphia Fed, Huck, dat de Fed de rente zou moeten verlagen, maar niet onmiddellijk. Enkele van zijn collega’s hebben onlangs een campagne gelanceerd om ‘een renteverlaging om het vuur te doven’, die krachtig ingaat tegen de breed verwachte renteverlaging op de markt begin 2024. In tegenstelling hiermee is Huck’s standpunt gematigder.</p>
<p>“Het is belangrijk voor ons om de rente te verlagen. We hoeven niet te snel te handelen, noch zullen we onmiddellijk actie ondernemen,” zei Huck in een lokaal radiointerview op woensdag.</p>
<p>Hij zei: “We zullen de rentetarieven op het huidige niveau houden voordat we ze gaan verlagen.”</p>
<p>Huck’s opmerkingen zijn meer ondersteunend voor de volgende beleidsaanpassing van de Fed, namelijk een renteverlaging, in plaats van het soort weerlegging van zijn collega’s in de afgelopen dagen. Hij zei dat hoewel overheidsgegevens terugkijken, de economie lijkt sneller af te zwakken dan uit de gegevens blijkt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<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 zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>