RGFnZWxpamtzIG5pZXV3cyB8IERlIFNFQyBoZWVmdCBkZSBkZWFkbGluZSB2b29yIGRlIGFhbnZyYWFnIHZhbiBCaXRjb2luIFNwb3QgRVRGJ3MgYWFuZ2Vrb25kaWdkOyBEZSBuZXR3ZXJrYWN0aXZpdGVpdCB2YW4gU29sYW5hIGhlZWZ0IGVlbiByZWNvcmRob29ndGUgYmVyZWlrdDsgRGUgQml0Y29pbi1oYWx2ZXJpbmdzdGlqZCBpcyB

2023-12-25, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17034888791_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20SEC20kondigt20uiteindelijke20deadline20aan20voor20spot20ETFs20Solanas20online20activiteitsgegevens20stellen20een20record20voor20het20jaar425304"><a name="Crypto Dagelijkse Samenvatting: SEC kondigt uiteindelijke deadline aan voor spot ETF’s, Solana’s online activiteitsgegevens stellen een record voor het jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: SEC kondigt uiteindelijke deadline aan voor spot ETF’s, Solana’s online activiteitsgegevens stellen een record voor het jaar</h2><p>Volgens bronnen aangehaald door Reuters, hebben Amerikaanse SEC-functionarissen gesproken met vertegenwoordigers van ten minste zeven uitgevers die hopen te lanceren <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s in het begin van 2024 en vertelde minstens twee bedrijven om uiterlijk eind 2024 definitieve wijzigingen in te dienen. Volgens een openbaar memorandum en twee bronnen die bekend zijn met de zaak, zal de SEC op 10 januari beslissen of ze het gezamenlijke voorstel tussen ARK en 21 Shares goedkeuren of afwijzen. De meeste uitgevers verwachten dat de SEC meerdere aanvragen tegelijkertijd goedkeurt enkele dagen voor de deadline.</p>
<p>De leidinggevenden van de twee bedrijven die met regelgevende instanties hebben gesproken, verklaarden dat vanwege de vertrouwelijkheid van de besprekingen de SEC 29 december als uiterste deadline heeft gesteld voor het bijwerken van de documenten. Uitgevers die de deadline niet halen, zullen niet worden opgenomen in de eerste batch mogelijke goedkeuringen voor spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s begin januari.</p>
<p>Volgens de analyse van voormalig SEC-functionaris John Reed Stark kan de politieke erfenis van SEC-voorzitter Gary Gensler de goedkeuring zijn van Bitcoin spot ETF’s.</p>
<p>Na de prijs van SOL met 100% is gestegen in vergelijking met vorige maand, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het netwerk heeft ook een record gevestigd voor nieuwe en actieve adressen op het netwerk voor het jaar. Volgens de gegevens van The Block heeft het Solana-netwerk, hoewel er nog een week over is voor de maand, een record gevestigd voor het aantal nieuwe en actieve adressen dat elke maand wordt toegevoegd. Het aantal actieve Solana-netwerkadressen is met ongeveer 50% gestegen ten opzichte van november en heeft meer dan 15,6 miljoen bereikt, een stijging ten opzichte van het record van 15,2 miljoen in januari van dit jaar. Op dit moment heeft het aantal nieuwe adressen dat in december is toegevoegd ook een record van 6,8 miljoen bereikt, terwijl het vorige record in mei 2023 6,6 miljoen bedroeg.</p>
<p>Op 24 december heeft de Japanse regering volgens Coinpost de belastinghervormingscontouren voor het begrotingsjaar 2024 goedgekeurd tijdens een kabinetsvergadering op de 22e. De wijziging omvat de volgende veranderingen, die van toepassing zijn op bedrijven die door derden uitgegeven crypto-activa (virtuele valuta) aanhouden en niet onderworpen zullen zijn aan belasting over de marktwaarde. Door deze belastinghervorming zal de reikwijdte van de toepassing van de eindejaarsmarktwaardebepaling in de Wet op de vennootschapsbelasting veranderen. Voorheen werden door derden uitgegeven crypto-activa (virtuele valuta) die door rechtspersonen werden gehouden, erkend als winst of verlies bij het eindejaarsboekhouden op basis van het verschil tussen de marktwaarde en de boekwaarde. Echter, door deze hervorming zal de toepassing van deze marktwaardebepaling worden afgeschaft voor langdurige houders. Het wetsvoorstel zal in januari volgend jaar aan het Congres worden voorgelegd en vereist goedkeuring van het Huis van Afgevaardigden en de Senaat.</p>
<p>Op 23 december plaatste de bekende crypto-influencer Arthur Hayes een uitgebreid artikel op zijn blog, waarin hij ingaat op onderwerpen zoals veranderingen in het beleid van de Federal Reserve, gereguleerde gedecentraliseerde financiën (Permissioned DeFi), reële activa (RWA) en Bitcoin ETF’s. Hayes is van mening dat Bitcoin en cryptocurrency de beste manieren zijn om de waardedaling van fiatvaluta tegen te gaan. Hij vergelijkt ze met goud, de S&amp;P 500-index en de Nasdaq 100-index en wijst erop dat Bitcoin sinds 2020 aanzienlijk beter heeft gepresteerd dan andere risicovolle activa. Bij het bespreken van beleidswijzigingen bij de Federal Reserve benadrukte Hayes in het bijzonder de grote invloed van politieke factoren op beslissingen van de Federal Reserve.</p>
<p>Hij wees erop dat de voorzitter van de Federal Reserve, Jerome Powell, ooit de noodzaak benadrukte om de rente te verhogen om de op hol geslagen inflatie tijdens de post-pandemische periode het hoofd te bieden. Op basis van recente verklaringen en acties lijkt er echter een aanzienlijke verschuiving plaats te vinden in het beleid van de Federal Reserve en begint zij mogelijke renteverlagingen in 2024 te overwegen. Deze beleidswijziging weerspiegelt de directe impact van de huidige politieke situatie in de Verenigde Staten op het beleid van de Federal Reserve. Hayes’ analyse suggereert dat deze beleidsverandering het gevolg kan zijn van druk van politiek leiderschap, vooral in belangrijke verkiezingsjaren. Om de steun van de kiezers te krijgen, kunnen politieke leiders er de voorkeur aan geven een ruim monetair beleid te voeren om de economische groei te stimuleren en de prestaties van de financiële markten te verbeteren, zelfs als dit kan leiden tot inflatierisico’s op de lange termijn.</p>
<p>Hayes is kritisch over gereguleerde gedecentraliseerde financiën (Permissioned DeFi). Hij is van mening dat dit financiële model, dat gecentraliseerde en gedecentraliseerde elementen combineert, in strijd is met de kernprincipes van decentralisatie en mogelijk slechts een andere manier is voor traditionele financiële instellingen (TradFi) om te proberen retailbeleggers te benutten. Wat betreft de tokenisatie van activa in de echte wereld (RWAs), gelooft Hayes dat hoewel deze poging aantrekkelijk kan klinken, het vele uitdagingen zal tegenkomen bij de praktische uitvoering. Hij wees specifiek op het feit dat het tokeniseren van activa zoals onroerend goed en obligaties moeilijk kan zijn om te slagen vanwege een gebrek aan standaardisatie en liquiditeit.</p>
<p>Hayes heeft uiteindelijk een gereserveerde houding ten opzichte van Bitcoin ETF’s. Hij stelde voor dat als ETF’s zwaar worden vastgehouden en opgeslagen door traditionele financiële instellingen zonder gebruik te maken van de Bitcoin blockchain, dit een bedreiging kan vormen voor de waarde en het bestaan van Bitcoin. Hij benadrukte dat Bitcoin verschilt van andere valuta-activa in de geschiedenis, aangezien de waarde ervan ligt in zijn liquiditeit en gebruik, in plaats van alleen maar vasthouden.</p>
<p>Op 24 december, volgens de Bitcoin lockhalf-website, is de huidige blokhoogte minder dan 120 dagen verwijderd van het halveringstijdstip van Bitcoin. Het halveringstijdstip wordt verwacht op 22 april 2024 en de blokbeloning zal tijdens de sessie worden verlaagd van 6,25 BTC naar 3,125 BTC.</p>
<p>Op 25 december, volgens de gegevens van Token Unlocks, zullen deze week DYDX, YGG, IMX, OP en andere tokens eenmalig een grote ontgrendeling ervaren, met een totale waarde van ongeveer $205 miljoen. Daarvan:</p>
<p>Om 12:00 (UTC) op 26 december, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> zal 575.000 <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">DYDX</a> ontgrendelen (ongeveer $1,73 miljoen), wat overeenkomt met 0,21% van de circulerende voorraad; Daarnaast zal DYDX deze week 35,49 miljoen circulerende tokens toevoegen (ongeveer $106 miljoen), wat overeenkomt met 13,19% van de circulerende voorraad;</p>
<p>Op 27 december om 14:00 (UTC) zal Yield Guild Games 16,69 miljoen YGG’s (ongeveer $7,15 miljoen) vrijgeven, wat overeenkomt met 5,94% van de circulerende voorraad;</p>
<p>Om 0:00 (UTC) op 28 december zal SingularityNET 9,25 miljoen AGIXs (ongeveer $3,26 miljoen) ontgrendelen, wat overeenkomt met 0,74% van de circulerende voorraad;</p>
<p>Op 29 december om 0:00 (UTC) ontgrendelt Immotable 1,22 miljoen IMX per dag gedurende 28 opeenvolgende dagen (ongeveer $ 2,99 miljoen per dag), goed voor 2,83% van het circulerende aanbod;</p>
<p>Om 4:00 (UTC) op 30 december <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> zal 24,16 miljoen OP’s (ongeveer $ 79,97 miljoen) ontgrendelen, goed voor 2,65% van het circulerende aanbod;</p>
<p>Op 31 december om 4:00 (UTC) wordt 4 miljoen SUI’s (ongeveer $2,92 miljoen) ontgrendeld, wat overeenkomt met 0,39% van de circulerende voorraad;</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag347332"><a name="Belangrijkste token trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste token trends van vandaag</h2><h3 id="h3-BTC323207"><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/1703489063BTC.png" alt=""><br>Vorige week sloot BTC consequent boven de $42.500. Vanochtend sloot het terug naar het midden van het kanaal. Deze week wordt verwacht dat er twee weerstandsniveaus worden getest: $45.345 en $47.990. De ondersteuningsniveaus blijven op $40.280 en $38.399, wat duidt op voortdurende volatiliteit op hoog niveau op middellange termijn.</p>
<h3 id="h3-ETH321594"><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/1703489088ETH.png" alt=""><br>ETH handhaafde vorige week een hoog niveau van oscillatie boven $2.135. Deze week wordt een voortzetting van de opwaartse trend verwacht, met als doel $2.489 en $2.838 op de middellange termijn. Gebruikmakend van een risico-rendement strategie voor spot- en contracten, met een korte termijn focus op ondersteuning op $2.135.</p>
<h3 id="h3-COMP742349"><a name="COMP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>COMP</h3><p><img src="https://gimg2.gateimg.com/image/article/1703489125COMP.png" alt=""><br>De daggrafiek is een jaar en een half lang gecombineerd, wat wijst op een mogelijke opwaartse beweging. Deze week kan een bullish trend brengen, met ondersteuning op de bovengrens van de trend en $54.82. Doorbraakdoelen zijn onder andere $64.97, $72.85, $77.71 en $81.64.</p>
<h2 id="h2-Macro20niveau20de20renteverlaging20vlam20blijft20zich20verspreiden20let20op20liquiditeitstekort20tijdens20de20kerstvakantie877232"><a name="Macro niveau: de ‘renteverlaging vlam’ blijft zich verspreiden, let op liquiditeitstekort tijdens de kerstvakantie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro niveau: de ‘renteverlaging vlam’ blijft zich verspreiden, let op liquiditeitstekort tijdens de kerstvakantie</h2><p>Afgelopen week verschenen verschillende Fed-functionarissen snel na de ‘duifachtige houding’ van voorzitter Powell om de marktverwachtingen te temperen. Maar na verschillende indrukwekkende inflatierapporten die op donderdag en vrijdag werden vrijgegeven, werd de markt meer overtuigd dat de Fed de rente in maart volgend jaar zal verlagen.</p>
<p>Afgelopen vrijdag daalde de Amerikaanse dollar index licht tijdens de Europese sessie en raakte kort een intraday dieptepunt van 101,42. Echter, het herwon wat terrein tijdens de Amerikaanse sessie en sloot uiteindelijk 0,08% lager op 101,70. Het rendement van 10-jarige Amerikaanse staatsobligaties daalde eerst en steeg vervolgens, en sloot af op 3,9% tijdens de Amerikaanse marktperiode, uiteindelijk sluitend op 3,901%; Het rendement op 2-jarige Amerikaanse staatsobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,329%.</p>
<p>Spotgoud steeg ooit boven het niveau van $2.070, bereikte een nieuw hoogtepunt in bijna twee weken, maar slaagde er uiteindelijk niet in om boven het niveau van $2.070 te stabiliseren en gaf het grootste deel van zijn winsten op, met een stijging van 0,34% tot $2.052,99 per ounce; Spotzilver daalde aanzienlijk op de Amerikaanse markt en benaderde kortstondig de 24-grens, om uiteindelijk met 0,87% te dalen tot $24,19 per ounce.</p>
<p>Als gevolg van marktzorgen dat de aankondiging van Angola om zich terug te trekken uit de OPEC de productie verder zou kunnen verhogen, is de internationale ruwe olie licht gedaald. WTI-ruwe olie werd geblokkeerd rond de $75 en stortte vervolgens aanzienlijk in tijdens de Amerikaanse sessie, waarbij het uiteindelijk 0,7% lager sloot op $73,93 per vat; Brent-ruwe olie slaagde er nog steeds niet in om boven de $80 te stabiliseren en sloot uiteindelijk 0,6% lager op $78,87 per vat.</p>
<p>Voor de Amerikaanse aandelenmarkt steeg de S&amp;P 500 index alleen al in december met meer dan 4% en heeft sinds het begin van dit jaar in totaal 24% opgebouwd, minder dan 1% verwijderd van historische hoogtepunten. Bovendien sloot de Amerikaanse S&amp;P 500 index met een stijging van 0,17%, terwijl de door technologie gedomineerde Nasdaq Composite Index met 0,19% steeg. De Dow Jones Industrial Average sloot 0,05% lager, en het is vermeldenswaardig dat de drie belangrijkste Amerikaanse aandelenindexen hun achtste opeenvolgende week van winst hebben genoteerd.</p>
<p>Als we naar de geschiedenis kijken, kan dit momentum op korte termijn aanhouden. Het einde van het jaar is vaak een sterke periode voor de aandelenmarkt, en dit fenomeen staat bekend als de ‘Santa Claus opleving’.</p>
<p>Bovendien, hoewel het stemmende comité van de Federal Reserve op het punt staat een jaarlijkse rotatie te ondergaan, en de stemmende leden in 2024 iets havikachtiger zijn dan degenen die in 2023 aftreden, verwacht de markt niet dat dit de verwachting zal veranderen van de Federal Reserve om volgend jaar over te gaan tot renteverlagingen.</p>
<p>Veel analisten geloven dat als de inflatie blijft dalen sneller dan verwacht, beleidsmakers van de Federal Reserve hopen de rente te verlagen met meer dan de 75 basispunten die blijken uit de laatste prognose die vorige week is uitgebracht. De PCE-gegevens versterken alleen maar dit standpunt.</p>
<p>Bovendien suggereren sommige analisten dat er nog een reden is voor renteverlagingen volgend jaar, namelijk dat het ongewijzigd houden van de referentie-rente de werkelijke leenkosten zal verhogen naarmate de inflatie afneemt. Daarom moet de Federal Reserve de beleidsrente verlagen om overmatig aanhalen te voorkomen.</p>
<p>Nu de Verenigde Staten deze week de kerstvakantie ingaan, is het onwaarschijnlijk dat functionarissen van de Federal Reserve plotseling zullen verschijnen om aan de marktverwachtingen te voldoen, en de vlam van renteverlagingen zal naar verwachting blijven woeden op de markt.</p>
<p>Voor handelaren kan een groot risico om deze week op te letten een gebrek aan liquiditeit zijn. Vanwege het feit dat veel handelaren offline zijn vanwege feestdagen, zal de marktliquiditeit schaars zijn.</p>
<p>Wanneer de liquiditeit laag is, kunnen financiële markten aanzienlijk schommelen zonder enig echt nieuws. Als er nieuwskoppen zijn, kan hun impact op de markt groter zijn dan normaal. Met andere woorden, lage liquiditeitsomstandigheden zullen de volatiliteit vergroten.</p>
<p>Deze Kerstmis valt op een maandag en is een feestdag in de meeste delen van de wereld, dus zullen de meeste aandelen- en obligatiemarkten gesloten zijn. De valutamarkt blijft echter gewoon open.</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 visie van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>