RGFnZWxpamtzIG5pZXV3cyB8IERlIFNFQyBrYW4gdmFuZGFhZyAnbWVlcmRlcmUnIGFhbnZyYWdlbiB2b29yIEJpdGNvaW4gU3BvdCBFVEYncyBnb2Vka2V1cmVuOyBFdGhlcmV1bSBTcG90IEVURidzIGt1bm5lbiBkaXQgamFhciBvcGVuYmFhciB3b3JkZW47IENlbHNpdXMgemFsIGhldCBzdGFrZW4gdmFuIGVlbiBncm9vdCBhYW50YWw

2024-01-05, 07:27
<p><img src="https://gimg2.gateimg.com/image/article/17044397301_6-05.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20SEC20kan20vandaag20meerdere20Bitcoin20spot20ETFaanvragen20goedkeuren20Ethereum20spot20ETFs20kunnen20dit20jaar20naar20de20markt20gaan658006"><a name="Crypto Dagelijkse Samenvatting: De SEC kan vandaag “meerdere” Bitcoin spot ETF-aanvragen goedkeuren, Ethereum spot ETF’s kunnen dit jaar naar de markt gaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De SEC kan vandaag “meerdere” <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF-aanvragen goedkeuren, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF’s kunnen dit jaar naar de markt gaan</h2><p>Vandaag, vrijdag, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF’s bereikten een kritiek tijdstip in marktvoorspellingen.</p>
<p>Gisteren hebben bekende financiële instellingen zoals VanEck, ARK Invest, Valkyrie, Fidelity, enz. hun aanvraag voor registratie van Bitcoin spot ETF-effecten ingediend bij de Amerikaanse SEC, met behulp van het 8-A12B-formulier, dat het nationale formulier voor registratie van effectenbeursnoteringen is.</p>
<p>Er wordt gemeld dat formulier 8-A alleen een effectenregistratie is die moet worden voltooid voordat de ETF wordt gelanceerd, en dit betekent niet dat de ETF is goedgekeurd. Om naar de beurs te gaan, hebben ETF’s nog steeds goedkeuring nodig van 19b-4, en geldige, goedgekeurde en volledige S-1 documenten zijn vereist.</p>
<p>Hierover tweette Bloomberg-analist Eric Balchunas dat de SEC definitieve meningen geeft over Bitcoin-spot-ETF’s en dat uitgevers binnenkort de definitieve 19b-4- en S-1-documenten zullen indienen. De goedkeuring van Bitcoin-spot-ETF’s nadert voltooiing, maar voor zover hij weet is er nog geen officiële goedkeuring verkregen.</p>
<p>De analist verklaarde dat als de SEC van plan is om de goedkeuring of afwijzing van de Bitcoin spot ETF-resolutie voort te zetten, het geen bijeenkomsten zal houden met grote beurzen (NASDAQ, Chicago Options Trading Platform, New York Stock Exchange) om opmerkingen te bepalen over de 19b-4s die zijn ingediend door uitgevers van Bitcoin spot ETF. De SEC heeft offline nauw contact gehad met uitgevers om zijn 19b-4s te verbeteren, in plaats van uitgebreide herindiening zoals de S-1s.</p>
<p>Fox-journalist Eleanor Terrett plaatste op sociale media dat de SEC vandaag een vergadering heeft met de beurs om de opmerkingen over de 19b-4s die zijn ingediend door uitgevers van Bitcoin-spot-ETF’s af te ronden.</p>
<p>Een andere bron van nieuws komt van TechCrunch-journalist Jacquelyn Melinek, die twitterde dat volgens bronnen die zeer dicht bij de zaak staan, de SEC ‘meerdere’ aanvragen voor Bitcoin spot ETF’s van bedrijven zal goedkeuren en naar verwachting vandaag (vrijdag) een kennisgeving zal doen. We zullen afwachten.</p>
<p>Aan de ene kant is de ETF-goedkeuringsmelding op de markt aangekomen, terwijl aan de andere kant investeringsbanken al begonnen zijn met onderhandelen met grote ETF-fondsen vooraf. Gisteren was JPMorgan Chase na Goldman Sachs ook in gesprek met Grayscale om op te treden als geautoriseerde deelnemer (AP) voor zijn spot Bitcoin ETF.</p>
<p>James Goleman, voormalig CEO van Morgan Stanley, een andere bekende investeringsbank, merkte gisteren op dat Bitcoin een zeer volatiele en speculatieve activa is en te maken heeft met regelgevende en sectorale onrust. Gorman verklaarde dat er vorig jaar geen bankencrisis was, slechts drie banken waren slecht beheerd. Hij verwacht dat de Federal Reserve dit jaar twee keer de rente zal verlagen om een economische recessie te voorkomen. Hij is optimistisch over de vooruitzichten voor de Amerikaanse economie en wijst erop dat de inflatie snel daalt, de outputgroei veerkrachtig is en de werkloosheid op een historisch laag niveau ligt, en gelooft dat de Amerikaanse economie waarschijnlijk niet in een recessie zal belanden.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures ETF komt ook binnenkort.</p>
<p>Op 4 januari, tijdens een besloten cryptoQuant-webinar, verklaarde Bloomberg ETF-analist James Seyfart dat de SEC Ethereum ‘impliciet’ had geaccepteerd als een grondstof bij het goedkeuren van Ethereum-futures ETF’s, wat betekent dat Ethereum-spot-ETF’s dit jaar genoteerd kunnen worden.</p>
<p>Seyfhart verklaarde dat als de SEC Ethereum als een effect beschouwt, dit in strijd zou zijn met de CFTC. Dit is ook de reden waarom het gelooft dat Ethereum spot ETF’s dit jaar zullen worden goedgekeurd. De eerste batch Ethereum-futures ETF’s in de Verenigde Staten werd op 2 oktober vorig jaar genoteerd voor de handel. De deadline voor de SEC om een definitieve beslissing te nemen over VanEck, ARK 21Shares en Hashdex Ethereum spot ETF’s is mei 2024.</p>
<p>Er is ander laatste nieuws over Ethereum dat de moeite waard is om aandacht aan te besteden. Op 4 januari is Celsius volgens media rapporten begonnen met het herstellen van activa en het herbalanceren van processen ter voorbereiding op de toewijzing van activa om voldoende liquiditeit te waarborgen. Celsius zal het staken op ETH vrijgeven, wat aanzienlijk rendement op onderpand biedt en bepaalde kosten kan compenseren die tijdens het herstructureringsproces zijn gemaakt. De ontgrendelingsactiviteiten in de komende dagen zullen een grote hoeveelheid ETH vrijgeven om tijdige toewijzing aan crediteuren te garanderen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag113765"><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-BTC626299"><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/1704440082BTC 0105.png" alt=""><br>De markt daalde deze week scherp naar het niveau van $40.750, waarbij posities met een hoog hefboomeffect werden geliquideerd. Het terugtrekkingspatroon wordt verwacht te worden aangedreven door volume in de loop van de tijd. Deze week wordt verwacht dat de markt een langzame opwaartse trend zal voortzetten met af en toe scherpe dalingen. Belangrijke ondersteuningsniveaus liggen op $41.500 en $40.450. Het is de verwachting dat de middellangetermijntrend een terugtrekking zal ervaren alvorens een opwaartse koers te hervatten, en het langetermijnperspectief blijft bullish.</p>
<h3 id="h3-ETH469842"><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/1704440111ETH 0105.png" alt=""><br>Na een verwachte opleving naar het weerstandsniveau van $2.260 na een terugval deze week, wordt een korte termijn correctie verwacht. Belangrijke steunniveaus worden vastgehouden op $2.135. Agressieve doelen zijn ingesteld op $2.135 en $2.097. Het conservatieve advies suggereert posities in te nemen na consolidatie.</p>
<h3 id="h3-WLD367277"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1704440153WLD 0105.png" alt=""><br>Deze week vond er een aanzienlijke verkoop plaats zoals voorspeld, waarbij het niveau van $2.505 werd bereikt en resulteerde in een daling van 35%. Er wordt verwacht dat er op korte termijn een schommeling zal plaatsvinden tussen $3.350 en $2.785. De tweede bodem zal waarschijnlijk standhouden op het ondersteuningsniveau van $2.584, met een middellangetermijnverwachting om te herstellen richting de doelniveaus van $5.22 en $5.81.</p>
<h2 id="h2-Macro20ADPgegevens20over20werkgelegenheid20zijn20positief20met20een20kans20van206720op20renteverlagingen20in20februari319161"><a name="Macro: ADP-gegevens over werkgelegenheid zijn positief, met een kans van 6,7% op renteverlagingen in februari." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: ADP-gegevens over werkgelegenheid zijn positief, met een kans van 6,7% op renteverlagingen in februari.</h2><p>Op donderdag onderdrukte de onverwacht sterke ADP-werkgelegenheidsgegevens marktverwachtingen voor renteverlagingen, waardoor de collectieve stijging van de Amerikaanse schatkistrendementen werd gedreven. Het rendement op de Amerikaanse schatkist van 10 jaar raakte opnieuw 4%, en sloot uiteindelijk op 4,002%; het rendement op de Amerikaanse schatkist van 2 jaar, dat gevoeliger is voor het beleidsrentetarief van de Federal Reserve, sloot op 4,38%. De Amerikaanse dollarindex steeg kort nadat de gegevens waren vrijgegeven, maar sloot uiteindelijk iets lager met 0,062% op 102,4.</p>
<p>Beïnvloed door de indrukwekkende prestaties van de ADP-werkgelegenheidsgegevens, nam spotgoud gedurende de dag al zijn winsten terug, zakte op een gegeven moment onder de 2040 grens voordat het herstelde en uiteindelijk met 0,16% steeg naar $2043,42 per ounce. Spotzilver schommelde smal rond het niveau van 23 en sloot uiteindelijk 0,14% lager af op $23,02 per ounce.</p>
<p>Als gevolg van de onverwachte aanzienlijke stijging van de brandstofvoorraden in de Verenigde Staten vorige week, die de impact van de consumptie van ruwe olievoorraden die de verwachtingen overtrof, overschaduwde, daalden de internationale olieprijzen tijdens de handel. WTI-ruwe olie daalde met 0,81% en sloot af op $72,34 per vat; Brent-ruwe olie sloot 0,99% lager op $77,62 per vat.</p>
<p>De Amerikaanse aandelenmarkt sloot op donderdag, met de Dow Jones iets hoger, de S&amp;P 500 0,3% lager en de Nasdaq 0,56% lager. Aandelen van digitale valuta herstelden zich, met MicroStrategy (MSTR. O) bijna 4% hoger en Coinbase (COIN. O) 2,2% hoger.</p>
<p>Op vrijdagavond zal het Amerikaanse ministerie van Arbeid meer marktgerichte data over niet-agrarische werkgelegenheid vrijgeven. Vanwege verschillende statistische methoden kunnen er aanzienlijke verschillen zijn tussen deze twee rapporten. Economen die door buitenlandse media zijn ondervraagd, voorspellen dat de niet-agrarische werkgelegenheid in december met 170.000 zal toenemen.</p>
<p>Functionarissen van de Federal Reserve houden het werkgelegenheidsrapport nauwlettend in de gaten om aanwijzingen te vinden over de kracht van de arbeidsmarkt en de impact ervan op de inflatie. Volgens de notulen van de vergadering van de Federal Reserve in december, die vanochtend vroeg zijn vrijgegeven, zijn de functionarissen van mening dat de arbeidsmarkt het evenwicht beter zal herstellen van de enorme vraag-aanbod mismatch van de afgelopen jaren.</p>
<p>Als gevolg van de impact van de ADP-werkgegevens, 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 93,3% en de kans op een renteverlaging van 25 basispunten is 6,7%. De kans dat de rentetarieven ongewijzigd blijven tegen maart volgend jaar is 35,4%, de kans op een cumulatieve renteverlaging van 25 basispunten is 60,4% en de kans op een cumulatieve renteverlaging van 50 basispunten is 4,2%.</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 beleggingsaanbevelingen.<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 glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards