RGFnZWxpamtzIE5pZXV3cyB8IEFyZ2VudGluacOrIGtldXJ0IEJpdGNvaW4tc2NoaWtraW5nc2NvbnRyYWN0ZW4gZ29lZDsgQmxhY2tSb2NrIGhlZWZ0IGRlIGhvb2dzdGUga2FucyBvbSBhbHMgZWVyc3RlIGdvZWRrZXVyaW5nIHRlIGtyaWpnZW4gdm9vciBTcG90IEVURidzOyBTT0wgRWNvc3lzdGVtIFRWTCBhYW56aWVubGlqayB0b2V

2023-12-22, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/17032280291_16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Argentini20keurt20Bitcoin20afwikkelingscontracten20goed20TVL20van20SOLecosysteem20blijft20aanzienlijk20stijgen361367"><a name="Crypto Dagelijkse Samenvatting: Argentinië keurt Bitcoin afwikkelingscontracten goed, TVL van SOL-ecosysteem blijft aanzienlijk stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Argentinië keurt <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> afwikkelingscontracten goed, TVL van SOL-ecosysteem blijft aanzienlijk stijgen</h2><p>Laten we ons eerst richten op de positieve regelgevende aspecten van sommige landen.</p>
<p>Volgens mediaberichten heeft Argentinië momenteel het gebruik van goedgekeurd. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> om contracten af te wikkelen, samen met andere cryptocurrencies en/of goedgekeurde grondstoffen, zoals rundvlees gemeten in kilogram of melk gemeten in liters.</p>
<p>Op 22 december bevestigde de Argentijnse minister van Buitenlandse Zaken, Diana Mondino, haar officiële standpunt over het accepteren van Bitcoin als contractuele overeenkomst in een baanbrekende verklaring, waaruit blijkt dat de Argentijnse regering bereid is om een Bitcoin-gedenomineerde overeenkomst aan te nemen en formeel vast te stellen, wat de juridische erkenning van Bitcoin binnen Argentinië aangeeft.</p>
<p>Hoewel details met betrekking tot implementatie en juridische nuances nog moeten worden uitgewerkt, markeert de verklaring van Mondino een cruciale stap in de richting van de legalisatie van Bitcoin in Argentinië. Deze stap kan ook dienen als een markt-catalysator en andere landen aanmoedigen om soortgelijke maatregelen te overwegen om Bitcoin op te nemen in hun wettelijk kader.</p>
<p>Volgens Cryptonews heeft de Russische president Poetin een wet ondertekend waarin de digitale roebel wordt opgenomen in de nationale belastingwetten. De nieuwe wet heeft termen toegevoegd zoals “digitale roebel” en “digitale roebelportemonnee,” en staat ook wetshandhavingsambtenaren en andere gerechtelijk aangewezen personen toe om CBDC-fondsen te “verhalen” van de portemonnee “wanneer er niet genoeg fiatvaluta op de bankrekening van de belastingbetaler staat.”</p>
<p>Bovendien stelt de wet belastingautoriteiten in staat om transacties van digitale roebelportefeuilles op te schorten. Belastingambtenaren kunnen ook platformexploitanten verzoeken om documenten te verstrekken waaruit blijkt dat geld is afgeschreven van de rekening van de belastingbetaler, en staan belastingambtenaren toe in beslag genomen tokens over te dragen aan het Russische ministerie van Financiën.</p>
<p>Er is de laatste tijd vooruitgang geboekt bij Bitcoin spot ETFs.</p>
<p>Onlangs tweette Fox Business-journalist Eleanor Terrett dat bronnen aan hem hebben onthuld dat de Amerikaanse SEC een gezamenlijke telefonische vergadering houdt met potentiële ETF-uitgevers om ervoor te zorgen dat elk Bitcoin-spot-ETF-product in contanten wordt gecreëerd, en de SEC verzoekt ook aanvragers om alle hints over fysieke inwisseling uit hun aanvraagdocumenten te verwijderen.</p>
<p>Volgens de weddenschappen op Amerikaanse gokwebsites is er een grote kans dat Bitcoin spot ETF’s worden goedgekeurd vóór 10 januari volgend jaar. BlackRock, ‘s werelds grootste fondsbeheermaatschappij, heeft het verkrijgen van goedkeuring van de SEC voor zijn spot Bitcoin ETF tot een belangrijke prioriteit voor het bedrijf gemaakt, en tegelijkertijd heeft BlackRock de hoogste kans om als eerste goedkeuring aan te vragen.</p>
<p>De oprichter en CEO van BlackRock, Larry Fink, noemde Bitcoin ooit ‘een internationaal bezit’ en ‘een middel om waarde op te slaan’, vergelijkbaar met de langetermijnstatus van goud. Er wordt gemeld dat BlackRock meer dan 400 traditionele ETF’s op de markt heeft en vijf keer met de SEC heeft gesproken over zijn aanvraag voor een spot Bitcoin ETF, waarvan de meest recente afgelopen dinsdag plaatsvond.</p>
<p>Hoewel de recente markthitte is weggekaapt door het Bitcoin-ecosysteem, is de belangrijkste Denchun-upgrade die <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staat op het punt om in te luiden is nog steeds de moeite waard om ieders aandacht te trekken.</p>
<p>Volgens CoinDesk intensiveren Ethereum-ontwikkelaars de testen voor de Denchun-upgrade van volgend jaar, wat een belangrijke mijlpaal is die gericht is op het verhogen van de gegevensopslagcapaciteit door middel van een nieuw proces genaamd ‘proto-dank sharding’. Ontwikkelaars bespraken hun doelen tijdens een tweewekelijkse vergadering en zijn van plan om Dencun op 17 januari op het Goerli-testnetwerk uit te voeren. Verwacht wordt dat deze upgrade de kosten van de tweede laag Rollup zal verlagen en de blockchain zal uitbreiden door de ‘blobs’ van gegevens te vergroten.</p>
<p>De ontwikkelaars stellen een testplanning op voor de Denchun-upgrade, met plannen om deze op 31 januari op het Sepolia-testnet en op 7 februari op het Holesky-testnet uit te voeren. Verwacht wordt dat de wijzigingen tegen het einde van februari naar het mainnet worden uitgerold. Deze data kunnen veranderen als gevolg van de resultaten van de testnet-fork.</p>
<p>Daarnaast, de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het ecosysteem begint te bloeien. Volgens mediaberichten heeft het <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Ecological Meme-project Bonk aangekondigd op het X-platform dat pre-sale tickets voor de Solana Annual Summit Breakpoint 2024 kunnen worden gekocht met BONK en de pre-sale eindigt op 5 januari. Volgens de laatste marktgegevens van Gate.io steeg BONK met 3,09% in 24 uur en wordt momenteel gemeld als $0,00002013. SOL-tokens gaan zelfs tegen de trend in, met een stijging van 17,10% in 24 uur en een huidige waarde van $96,86.</p>
<p>Op 21 december steeg de TVL van het Solana-netwerk naar $1,22 miljard, en er was een aanzienlijke stijging van de TVL voor meerdere protocollen in het Solana-ecosysteem. Daarvan bereikte de liquiditeitsstakingprotocol Jito TVL $578 miljoen, met een wekelijkse stijging van 23,32%; Het uitleenplatform marginfi TVL bereikte $330 miljoen, met een wekelijkse stijging van 36,27%; De liquiditeitsoplossing Kamino TVL bereikte $190 miljoen, met een wekelijkse stijging van 49,64%.</p>
<h2 id="h2-Belangrijkste20trends20van20de20hoofdtokens20van20vandaag69553"><a name="Belangrijkste trends van de hoofdtokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van de hoofdtokens van vandaag</h2><h3 id="h3-BTC37733"><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/1703228233BTC.png" alt=""><br>Deze week bleef schommelen op hoog niveau en convergeerden, en de korte termijn trend vormde nog steeds een W-bodemstructuur. Let op het fenomeen van korte termijn divergentie. Doorbraken zullen blijven kijken naar twee hoogtepunten: $45.345 en $47.990; Xiaguan raadt aan om twee steunpunten te behouden: $40.280 en 38.399. Dollar.</p>
<h3 id="h3-ETH640965"><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/1703228249ETH.png" alt=""><br>Het hoogste punt van deze week bleef boven de 2.135 dollar schommelen. Het heeft de neerwaartse trend op korte termijn doorbroken. Vergeleken met de reguliere sectoren is het nog steeds een lagedruksignaal. Het doel op middellange termijn is optimistisch over het bereiken van het niveau van 2.489 dollar en het niveau van 2.838 dollar. U kunt de strategische lay-out van de winst-verliesverhouding gebruiken, met kortetermijnondersteuning van $ 2,135.</p>
<h3 id="h3-BAND291275"><a name="BAND" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BAND</h3><p><img src="https://gimg2.gateimg.com/image/article/1703228275BAND.png" alt=""><br>De dagelijkse lijn doorbrak de grote neerwaartse trend en de korte termijn bereikte het einde van convergentie. Tegelijkertijd stapte het op twee ondersteuningsniveaus: $1.316 en $1.179. Het wordt aanbevolen om de basisprijs stabiel te houden en het langetermijndoel zal doorgaan naar $3.36, $6.09 en $7.30, $11.235 en de vorige hoogte van $23.28. Er is aanzienlijke ruimte voor een langetermijnpositie.</p>
<h2 id="h2-Macro20Amerikaanse20BBPindex20valt20tegen20met20een20kans20van20ongeveer208020op20renteverlagingen20in20maart442706"><a name="Macro: Amerikaanse BBP-index valt tegen, met een kans van ongeveer 80% op renteverlagingen in maart" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse BBP-index valt tegen, met een kans van ongeveer 80% op renteverlagingen in maart</h2><p>Om 21:30 uur Beijing-tijd op donderdag werd de definitieve geannualiseerde kwartaallijkse reële BBP-groei voor het derde kwartaal van de Verenigde Staten vastgesteld op 4,9%, lager dan de verwachte 5,20%. De daadwerkelijke kwartaallijkse consumptie-uitgaven in het derde kwartaal van de Verenigde Staten bedroegen een definitieve waarde van 3,1%, lager dan de verwachte 3,6%. De geannualiseerde kwartaallijkse kern-PCE-prijsindex in het derde kwartaal van de Verenigde Staten bedroeg een definitieve waarde van 2%, lager dan de verwachte 2,30%. Het aantal eerste aanvragen voor werkloosheidsuitkeringen in de Verenigde Staten voor de week die eindigde op 16 december bedroeg 205.000, lager dan de verwachte 215.000.</p>
<p>Op donderdag daalde de Amerikaanse dollarkoers scherp vóór de Amerikaanse markt, daalde onder de 102 mark en daalde naar een dieptepunt van een week van 101,73, uiteindelijk met 0,59% gesloten op 101,79. Amerikaanse obligatierendementen daalden eerst en stegen vervolgens, waarbij het rendement op 10-jarige Amerikaanse obligaties daalde naar een bijna 5-maands dieptepunt van 3,829% voordat het herstelde en uiteindelijk sloot op 3,892%; Het rendement op 2-jarige Amerikaanse staatsleningen, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,352%. De drie belangrijkste Amerikaanse aandelenindexen openden hoog en sloten hoog, waarbij de Dow Jones 0,87% steeg, de S&amp;P 500-index met 1,03% steeg en de Nasdaq Composite-index met 1,26% steeg.</p>
<p>Spotgoud herstelde opnieuw van de niveaus van $2.030 en $2.040 en steeg kortstondig naar een intraday hoogtepunt van $2046,04, om uiteindelijk 0,73% hoger te sluiten op $2.043,02 per ounce; Spotzilver steeg met 1,06% en sloot op $24,4 per ounce.</p>
<p>Als gevolg van de aankondiging van Angola om zich terug te trekken uit OPEC, groeiden de zorgen dat de productieverlagingen van OPEC+ de oliemarkt niet konden stimuleren, waarbij internationale ruwe olie eerst daalde en vervolgens steeg. WTI-ruwe olie daalde op een gegeven moment tot een intraday dieptepunt van $72,41, veerde toen op en sloot uiteindelijk 0,22% hoger op $73,90 per vat; Brent-ruwe olie daalde tot een intraday dieptepunt van $77,79 in de handel, herstelde vervolgens alle verloren terrein en sloot uiteindelijk 0,3% hoger op $79,35 per vat.</p>
<p>De neerwaartse herziening van een reeks economische gegevens verstevigde het vooruitzicht van een renteverlaging door de Federal Reserve. Het rendement van de 10-jarige schatkistobligatie daalde naar 3,84%, het laagste niveau sinds 27 juli. De Amerikaanse dollar index zakte onder de 102-markering en bereikte een dieptepunt van 101,82. De goudprijs steeg meer dan $10 op korte termijn na de bekendmaking van de gegevens en stond op $2040 per ounce, terwijl de zilverprijs op korte termijn met $0,1 steeg. Niet-Amerikaanse valuta’s stegen over het algemeen, waarbij de euro op 1,10 tegenover de Amerikaanse dollar stond en de Amerikaanse dollar binnen de dag met 1% daalde ten opzichte van de Japanse yen. De futures voor de S&amp;P 500-index en Nasdaq-index bleven hun opwaartse trend voortzetten en bereikten pre-market hoogtepunten.</p>
<p>Een reeks herzieningen van economische gegevens hebben het vooruitzicht van renteverlagingen versterkt. Volgens de ‘Federal Reserve Observation’ van CME is de kans dat de Federal Reserve de rentetarieven handhaaft in het bereik van 5,25% -5,50% in februari volgend jaar 85,5%, en de kans op een renteverlaging van 25 basispunten is 14,5%. De kans op handhaving van de rentetarieven ongewijzigd tot maart volgend jaar is 17,1%, de kans op een cumulatieve verlaging van 25 basispunten is 71,3% en de kans op een cumulatieve verlaging van 50 basispunten is 11,6%. Sommige analisten suggereren ook dat de kans op renteverlaging door de Federal Reserve in maart volgend jaar kan oplopen tot boven de 80%.</p>
<p>De vandaag en vrijdag vrijgegeven PCE-gegevens worden verwacht te bevestigen dat het inflatiepercentage voor de afgelopen zes maanden mogelijk terugkeert naar het jaarlijkse inflatiedoel van de Fed van 2%. Daarom kan de data voor de komende zes maanden ook vergelijkbaar traag zijn, wat zal helpen om de rechtvaardiging voor de renteverlagingen van de Fed in de komende kwartalen te versterken.</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 opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>