RGFnZWxpamtzIG5pZXV3cyB8IFNBVFMgb3ZlcnNjaHJlZWQgT1JESSBpbiBtYXJrdGthcGl0YWxpc2F0aWU7IFNFQyBrZXVydCBCaXRjb2luIFNwb3QgRVRGIGdvZWQgem8gdnJvZWcgYWxzIGphbnVhcmkgdm9sZ2VuZCBqYWFyOyBTJlAgaGVlZnQgZWVuIFN0YWJsZWNvaW4gRXZhbHVhdGllcmFwcG9ydCB1aXRnZWJyYWNodA==

2023-12-13, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17024477401_8.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20SATS20overtreft20ORDI20in20marktkapitalisatie20de20SEC20keurt20Bitcoin20spot20ETFs20goed20vanaf20januari20volgend20jaar602725"><a name="Crypto Dagelijkse Samenvatting: SATS overtreft ORDI in marktkapitalisatie, de SEC keurt Bitcoin spot ETF’s goed vanaf januari volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: SATS overtreft ORDI in marktkapitalisatie, de SEC keurt <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s goed vanaf januari volgend jaar</h2><p>Laten we eerst kijken naar de laatste ontwikkelingen in inschrijvingen die de laatste tijd veel aandacht van de markt hebben gekregen.</p>
<p>Gisteren bestond er een kwetsbaarheid CVE-2023-50428 in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Core-software voor versie 26.0 en Bitcoin Knots voor versie 25.1. knots20231115 is officieel overgenomen door NVD (National Vulnerability Database of the United States). Deze kwetsbaarheid maakt het mogelijk om gegevensdragergroottebeperkingen te omzeilen door gegevens te vermommen als code (bijv. met behulp van OP-FALSE OP-IF), wat werd misbruikt door ‘Inion’ in 2022 en 2023. De basis score van CVSS (Common Vulnerability Scoring ), die door NVD officieel is beoordeeld voor deze kwetsbaarheid, is 5.3, wat behoort tot het middelste risiconiveau.</p>
<p>In tegenstelling tot dit negatieve nieuws blijft het FOMO-sentiment van mensen ten opzichte van de inies toenemen.</p>
<p>Op 12 december heeft SATS volgens marktgegevens de totale marktwaarde van $1,135 miljard overschreden, met een tijdelijk rapport van $1,137 miljard, wat goed is voor de 62e plaats op de ranglijst van cryptomarktwaarde. Op het moment van publicatie heeft SATS tijdelijk een rapport van $0,00000053, met een stijging van 140,49% in 24 uur.</p>
<p>Het laatste nieuws over ETF’s, die zijn overschaduwd door de populariteit van de inies op de baan en zijn afgekoeld, is dat de Amerikaanse ETF-expert Nate Geraci op 13 december op haar sociale mediaplatform verklaarde dat ze heeft gecommuniceerd met Steven McClurg, medeoprichter van Valkyrie Funds, die verklaarde dat ze een zeer gedetailleerd gesprek heeft gehad met de SEC over de structuur van Bitcoin spot ETF’s en “heel dichtbij” is om te bereiken een consensus. Verwacht wordt dat Bitcoin spot ETF’s nieuwe fondsaandelen in contanten zullen creëren.</p>
<p>Bovendien verklaarde Nate Geraci dat het productvoorbereidingswerk en de backend-infrastructuur voor de lancering van de ETF klaar zijn en dat de SEC Bitcoin-spot-ETF’s op elk moment na 2 januari kan goedkeuren.</p>
<p>De langverwachte Bitcoin-obligatie in El Salvador, de “Vulkaan Obligatie,” heeft goedkeuring van de toezichthouders ontvangen.</p>
<p>Op 11 december heeft het Comité Digitale Activa van El Salvador de uitgifte van vulkanische obligaties goedgekeurd, die naar verwachting in het eerste kwartaal van 2024 zullen worden gelanceerd. El Salvador heeft op 11 januari belangrijke wetgeving aangenomen om voor het eerst een juridisch kader te bieden voor door Bitcoin ondersteunde obligaties. Vulkanische obligaties hebben als doel om soevereine schulden af te lossen en de bouw van de voorgestelde Bitcoin-stad in het land te financieren. Het Nationaal Bitcoin-kantoor (ONBTC) heeft aangekondigd dat de obligaties zullen worden uitgegeven op Bitcoin Securities, een blockchain-aandelen- en obligatiehandelswebsite geregistreerd in El Salvador.</p>
<p>Bovendien heeft El Salvador onlangs een Bitcoin-miningproject van $1 miljard gelanceerd dat gebruik zal maken van de vulkanische hulpbronnen van het land door samenwerking met Luxor Technology.</p>
<p>Gisteren 12 december was de 13e verjaardag van de laatste openbare mededeling van Satoshi Nakamoto, de maker van Bitcoin, op het Bitcoin-forum. In dit bericht vermeldde Satoshi Nakamoto dat er nog steeds meer werk moet worden verricht met betrekking tot DoS-aanvallen (denial of service). Deze uitspraak weerspiegelt zijn bezorgdheid over de beveiliging van Bitcoin-netwerken, met name in het weerstaan van potentiële denial of service-aanvallen. Sindsdien heeft Satoshi Nakamoto niet meer in het openbaar gesproken en zijn identiteit en verblijfplaats blijven een van de grootste mysteries in de digitale valuta-industrie.</p>
<p>Op dinsdag publiceerde het gerenommeerde ratingbureau Standard&amp;Poor’s Global Ratings een beoordeling van de stabiliteit van acht stablecoins, waaronder Dai (Dai), First Digital USD (FDUSD), <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> (USDT), <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> (Frax), <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a> (TUSD), <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC), USDP en GUSD.</p>
<p>Analisten richten zich voornamelijk op de kwaliteit van stablecoin-activa die stabiliteit ondersteunen. De algehele kwaliteit wordt gemeten aan de hand van bewaringsrisico, krediet en marktwaarde. Uit de uatieresultaten blijkt dat USDC, USDP en GUSD een ‘sterke’ beoordeling hebben gekregen. USDT, DAI en FDUSD kregen een ‘beperkte’ beoordeling, terwijl <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> en TUSD een ‘zwakke’ beoordeling kregen. Analisten verklaarden dat bij de eerste uatie geen enkele stablecoin de hoogste beoordeling van ‘zeer sterk’ heeft gekregen.</p>
<h2 id="h2-Belangrijkste20Trends20van20vandaag20in20Tokens831637"><a name="Belangrijkste Trends van vandaag in Tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Trends van vandaag in Tokens</h2><h3 id="h3-BTC829544"><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/1702447781BTC.png" alt=""><br>De handelsvolume van CME is deze week scherp gedaald en de markt opent vanochtend opnieuw lager. Verwacht wordt dat de markt deze week blijft terugtrekken naar het ondersteuningsniveau van $40.400, met aanvullende ondersteuning op $37.980. Er wordt later een tweede significante terugtrekking verwacht. Voor longposities wordt aanbevolen om standvastig te blijven op het ondersteuningsniveau van $35.333.</p>
<h3 id="h3-ETH369583"><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/1702447802ETH.png" alt=""><br>Vorige week werd de doelkoers van $2.381 voor ETH bereikt met een hoogtepunt van $2.386. Deze week wordt een retracement verwacht, met ondersteuningsniveaus op $2.135 en $2.037. Het korte termijn hoogtepunt is bereikt, wat wijst op een korte termijn bearish en lange termijn bullish correctieperiode. Overweeg opnieuw binnen te gaan op het ondersteuningsniveau van $1.951.</p>
<h3 id="h3-BIGTIME139969"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1702447824BIGTIME.png" alt=""><br>BIGTIME, sinds medio tot eind oktober gepositioneerd, is meer dan een maand stil gebleven. Het heeft onlangs een aanzienlijke stijging laten zien, met een piek van bijna $1 in de afgelopen week en een algehele stijging van meer dan tien keer. Korte termijn consolidatie op hoge niveaus is mogelijk. Korte termijn ondersteuning ligt op $0.5712 en $0.4494, met een mogelijke terugval naar $0.2316 voordat de opwaartse trend wordt voortgezet.</p>
<p>Op de lange termijn is er een kans voor BIGTIME om de algehele chain game markt te leiden, waardoor de marktwaarde naar nieuwe hoogten wordt gestuwd en een triple-win situatie wordt gecreëerd met spot- en contractwinsten.</p>
<h2 id="h2-Macro20Met20de20onverwachte20stijging20van20de20CPI20kunnen20renteverlagingen20binnenkort20arriveren850234"><a name="Macro: Met de onverwachte stijging van de CPI, kunnen renteverlagingen binnenkort arriveren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Met de onverwachte stijging van de CPI, kunnen renteverlagingen binnenkort arriveren</h2><p>Op dinsdag vertraagde het jaar-op-jaar groeipercentage van de ongecorrigeerde CPI van november in de VS zoals gepland tot 3,1%, en het maand-op-maand groeipercentage versnelde onverwacht tot 0,1%; Het jaar-op-jaar groeipercentage van de kern-CPI was 4%, wat onveranderd bleef van oktober en versnelde tot 0,3% maand-op-maand, beide in lijn met de verwachtingen. Handelaren verwachten nu dat de eerste renteverlaging door de Federal Reserve zal plaatsvinden in mei 2024.</p>
<p>Als gevolg van de onverwachte versnelling van de maand op maand CPI-groeisnelheid in de Verenigde Staten in november, die de verwachting van marktrente-verlagingen raakte, steeg het rendement van de Amerikaanse schatkistbrief op korte termijn gedurende de dag. Het rendement van de Amerikaanse schatkistbrief op middellange tot lange termijn daalde opnieuw na de publicatie van de resultaten van de 30-jarige Amerikaanse schatkistbriefveiling, en het rendement van de 10-jarige Amerikaanse schatkistbrief sloot op 4,202%; Het rendement van de tweejarige Amerikaanse schatkistbrief, dat gevoeliger is voor het beleidsrente van de Federal Reserve, sloot op 4,735%. De Amerikaanse dollarindex bereikte een nieuw hoogtepunt na de publicatie van CPI-gegevens, maar gaf vervolgens zijn winst op en sloot uiteindelijk 0,259% lager op 103,82.</p>
<p>De goudprijs steeg eerst en daalde vervolgens, waarbij hij kort onder het niveau van $1.980 kwam en uiteindelijk iets lager sloot met 0,02% op $1.980,96 per ounce, nog steeds zwevend op een laagste punt van drie weken; de zilverprijs sloot 0,1% lager op $22,77 per ounce.</p>
<p>De tegenvaller in de verwachtingen van een vroege renteverlaging door de Federal Reserve betekent tot op zekere hoogte dat er een groter risico is op een economische harde landing, waardoor vroege pogingen om internationale ruwe olie te laten herstellen aan momentum verliezen en een nieuw dieptepunt van 5 maanden bereiken. WTI-ruwe olie maakte een lichte stijging in intraday-daling tot 4% mee en sloot uiteindelijk 3,74% lager op $68,8 per vat; Brent-ruwe olie sloot 3,53% lager op $73,58 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen stegen langzaam, waarbij de Dow Jones Industrial Average met 0,48% steeg, de Nasdaq met 0,7% steeg en de S&amp;P 500-index met 0,46% steeg, wat vier opeenvolgende handelsdagen van winst markeert en een nieuwe slotkoers hoogte sinds januari 2022.</p>
<p>Na de publicatie van de CPI-gegevens heeft de Amerikaanse minister van Financiën Yellen commentaar gegeven op de CPI-gegevens en verklaard dat de stijgende reële rentetarieven van invloed kunnen zijn op de beslissing van de Federal Reserve over het rentebeleid.</p>
<p>Op macro niveau werd verwacht dat de renteverlaging in de tweede helft van volgend jaar zou plaatsvinden, maar nu heeft de markt voorspeld dat deze zal worden vervroegd naar mei. Na volgend jaar kan deze verwachting blijven verschuiven. Daarom zal de verwachting van renteverlaging alleen maar toenemen en niet afnemen, en het aantal renteverlagingen zal alleen maar stijgen en niet dalen. Dit vormt de basis voor de macro-economische ondersteuning van een bullmarkt die volgend jaar begint.</p>
<p>Met deze premisse zal de hele financiële markt opnieuw borrelen, en de cryptomarkt zal nog meer borrelen, dus volgend jaar is een kansrijk jaar.</p>
<p>Volgens gegevens van het analyseplatform Glassnode heeft de gerealiseerde nettowinst die door Bitcoin-investeerders in Amerikaanse dollars is vergrendeld, $324 miljoen per dag bereikt, wat nog steeds één orde van grootte lager is dan de piek die werd ervaren in de latere stierenmarkt van 2021, toen de piek boven de $3 miljard per dag uitkwam.</p>
<p>Dit geeft aan dat de huidige prestaties van Bitcoin grotendeels binnen het bereik van een vroege bullmarkt vallen, in plaats van een latere bullmarkt. Dus, iedereen moet de kansen in de vroege bullmarkt koesteren, goed voorbereid zijn en samen uitkijken naar het uitbreken van de bullmarkt.</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 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 genoemd. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>