RGFnZWxpamtzIG5pZXV3cyB8IEVURidzIHdvcmRlbiBuYWFyIHZlcndhY2h0aW5nIGRlemUgd29lbnNkYWcgZ29lZGdla2V1cmQ7IERlIHZvb3JnZXN0ZWxkZSBiZXBlcmtpbmdzaW5zY3JpcHRpZXMgemlqbiBuaWV0IGdvZWRnZWtldXJkOyBIZXQgYWFudGFsIGZ5c2lla2UgaGFuZGVsYXJlbiBkYXQgQlRDIGFjY2VwdGVlcnQsIGlzIHZ

2024-01-08, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17046976651_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20ETFs20worden20naar20verwachting20al20goedgekeurd20vanaf20woensdag20deze20week20het20voorstel20om20inschrijvingen20te20beperken20is20nog20niet20goedgekeurd944605"><a name="Crypto Dagelijks Overzicht: ETF’s worden naar verwachting al goedgekeurd vanaf woensdag deze week, het voorstel om inschrijvingen te beperken is nog niet goedgekeurd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: ETF’s worden naar verwachting al goedgekeurd vanaf woensdag deze week, het voorstel om inschrijvingen te beperken is nog niet goedgekeurd</h2><p>Deze week markeert een reeks belangrijke deadlines en is het hoogtepunt van jarenlange inspanningen om exchange-traded funds (ETF’s) te lanceren die worden ondersteund door <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> in de Verenigde Staten. Instellingen die hopen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s uit te geven, moeten hun last-minute wijzigingen in hun lopende aanvragen voor maandagmiddag Washington tijd indienen. De Amerikaanse Securities and Exchange Commission is van plan om te stemmen over de 19b-4 documenten die zijn ingediend door beurzen in de komende dagen.</p>
<p>Regelgevende instanties kunnen al dan niet actie ondernemen op de aanvraag van de uitgever (S-1) ongeveer tegelijkertijd. Als de SEC de twee benodigde goedkeuringen goedkeurt, kunnen ETF’s al vanaf de volgende werkdag beginnen met handelen. Een vertegenwoordiger van de Amerikaanse Securities and Exchange Commission weigerde commentaar te geven op de status van de aanvraag.</p>
<p>Fox Business-journalist Eleanor Terrett tweette dat BlackRock verwacht dat zijn nieuwe Bitcoin-spot-ETF woensdag van deze week goedkeuring van de SEC zal ontvangen, en er wordt ook verwacht dat ETF’s van andere vermogensbeheerbedrijven goedkeuring zullen ontvangen. Bovendien zal BlackRock volgens ingewijden binnen ongeveer drie dagen ontslagen aankondigen, waarbij ongeveer 600 werknemers betrokken zijn, wat neerkomt op 3% van zijn wereldwijde personeelsbestand.</p>
<p>Hoofd van digitale activa-onderzoek bij VanEck, Matthew Sigel, verklaarde tijdens een evenement op Twitter Space dat hij van een bron heeft vernomen dat er meer dan $2 miljard aan fondsen klaarstaat om te worden geïnvesteerd in BlackRock Bitcoin spot ETF’s in de eerste week na hun notering, van bestaande Bitcoin-houders.</p>
<p>Volgens Cointellegragh zullen vermogensbeheerbedrijven die een Bitcoin spot ETF aanvragen, de definitieve herziene documenten op 8 januari indienen. Analisten verwachten dat de transactie op 11 januari zal beginnen. In de volgende fase zal de SEC een beslissing nemen en kunnen SEC-leden stemmen. Maar volgens Bloomberg-analist Eric Balchunas stonden er tot 11 januari geen afspraken op de openbare agenda van de SEC, maar de SEC zou beslissingen kunnen nemen met behulp van haar autorisatiebeleid.</p>
<p>Beleggingsmaatschappij VanEck verklaarde op het X-platform dat na goedkeuring van de Bitcoin spot ETF, het 5% van de winst van zijn spot Bitcoin ETF zal schenken om gedurende ten minste 10 jaar de Bitcoin core-ontwikkelingsorganisatie Brink te ondersteunen. VanEck wacht momenteel op goedkeuring van de SEC om zijn spot Bitcoin ETF te lanceren.</p>
<p>Bloomberg-analist James Seyfhart tweette dat goud-ETF’s meer potentiële problemen (onzuiverheden, vervalsingen, etc.) hebben dan Bitcoin ETF’s. Niemand dwingt iemand om potentiële Bitcoin ETF’s te kopen. ETF’s zullen Bitcoin zelf niet veranderen. Ze zijn gewoon een keuze. Het voordeel van een vrije markt is dat we de markt kunnen laten beslissen of Bitcoin ETF’s waarde hebben.</p>
<p>Op 7 januari heeft Luke Dashjr, een ontwikkelaar van de Bitcoin Core-client, een voorstel ingediend met de titel ‘datacarriersize: Match more datacarrying # 28408’ om te bespreken of inies beperkt moeten worden. Na discussie tussen meerdere ontwikkelaars is het voorstel niet goedgekeurd en is momenteel gesloten.</p>
<p>Op 7 januari, Vitalik Buterin, medeoprichter van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, gaf financieel advies over het onderwerp ‘moeten beleggingsportefeuilles gediversifieerd zijn’ op sociale media: Het diversifiëren van beleggingsportefeuilles is goed; Sparen, streven naar sparen totdat er genoeg geld is om jaren aan uitgaven te dekken, financiële zekerheid is vrijheid; Handhaaf een vlakke beleggingsportefeuille voor de meeste individuen; Gebruik niet meer dan twee keer de hefboomwerking, nooit.</p>
<p>Het aantal fysieke handelaren dat Bitcoin accepteert, heeft een nieuw hoogtepunt bereikt. Het aantal fysieke handelaren dat Bitcoin accepteert, is bijna verdrievoudigd in 2023, met meer dan 6000 handelaren wereldwijd die Bitcoin-betalingen accepteren, waarvan er veel zich in Latijns-Amerika bevinden. Dit totaal is bijna drie keer zo groot als het aantal leveranciers dat Bitcoin accepteert aan het einde van 2022 - op dat moment waren er slechts 2200. Bitcoin-handelaren zijn over de hele wereld verspreid, vooral geconcentreerd in Europa, de Verenigde Staten en Latijns-Amerika, terwijl de acceptatie in Oost-Azië relatief laag is. Vanwege het verbod op cryptocurrencies heeft China bijna geen handelaren die Bitcoin accepteren.</p>
<p>Wat betreft het ontgrendelen van tokengegevens deze week, volgens Token Unlocks-gegevens, van 8 januari tot 14 januari zullen GLMR, APT en CYBER-tokens een eenmalige ontgrendeling ervaren, met een totale vrijgave waarde van ongeveer $236 miljoen. Daarvan:</p>
<p>Op 11 januari om 00:00 (UTC), <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> token GLMR zal 304 tokens ontgrendelen (ongeveer $1,2 miljoen), wat overeenkomt met 0,38% van de circulerende voorraad;</p>
<p>Op 12 januari om 01:59 (UTC), <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> token APT zal 24,84 miljoen (ongeveer $225 miljoen) ontgrendelen, goed voor 8,05% van de circulerende voorraad;</p>
<p>Op 14 januari om 14:24 (UTC) zal CyberConnect-token CYBER 1,26 miljoen ontgrendelen (ongeveer $9,03 miljoen), wat overeenkomt met 8,51% van de circulerende voorraad.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens202336"><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-BTC970718"><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/1704697705BTC.png" alt=""><br>Vorige week daalde BTC terug naar een laagste steun van $40.750 en veerde toen op naar de trendas. Vanochtend daalde het opnieuw naar het niveau van $43.000. De trend voor deze week wordt verwacht om verder naar beneden te gaan. Het wordt geadviseerd om niet te speculeren over korte-termijnbewegingen. Let op potentiële short-kansen bij een doorbraak naar beneden, met belangrijke steunniveaus op $40.280 en $38.400 voor de middellange termijn.</p>
<h3 id="h3-ETH86587"><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/1704697720ETH.png" alt=""><br>Het vier-uur grafiek toont tekenen van een topformatie. Korte-termijn aandacht is gericht op of de $2.135 ondersteuning standhoudt, wat een kritisch mid-lange termijn keerpunt is. Indien doorbroken, kan het ondersteuningsniveaus op $2.037 en $1.974 opnieuw bezoeken. Korte-termijn handel kan overwogen worden bij een terugval, terwijl een lange-termijn bullish standpunt behouden blijft.</p>
<h3 id="h3-POWR590967"><a name="POWR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>POWR</h3><p><img src="https://gimg2.gateimg.com/image/article/1704697732POWR.png" alt=""><br>Duidelijke tekenen van marktmanipulatie zijn zichtbaar in de recente bewegingen van POWR. Nadat het bijna $0,9425 had bereikt vanuit een basis van $0,1245, daalden de prijzen binnen 2 uur snel onder $0,5195, wat een risico op liquidatie van longposities met zich meebrengt. Korte termijn ondersteuning ligt op $0,4278, wat een kans biedt op een herstel met zorgvuldig risicobeheer. Op lange termijn wordt het aanbevolen om spotposities te behouden vanwege mogelijke liquidatierisico’s die gepaard gaan met contracten.</p>
<h2 id="h2-Macro20De20eerste20week20van20het20nieuwe20jaar20is20volatiel20de20Fed20sluit20de20mogelijkheid20van20opnieuw20verhogen20van20de20rente20niet20uit477689"><a name="Macro: De eerste week van het nieuwe jaar is volatiel, de Fed sluit de mogelijkheid van opnieuw verhogen van de rente niet uit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De eerste week van het nieuwe jaar is volatiel, de Fed sluit de mogelijkheid van opnieuw verhogen van de rente niet uit</h2><p>In de eerste week van het nieuwe jaar, na de opleving van de Amerikaanse staatsobligaties en de versterking van de Amerikaanse dollar, nam het risicosentiment af van een uiterst optimistische toestand. De aandelenmarkt begon slecht, met de drie belangrijkste Amerikaanse aandelenindexen die een einde maakten aan hun negen opeenvolgende wekelijkse winsten en de Nasdaq die zijn grootste wekelijkse daling sinds september doormaakte. Goud noteerde zijn eerste wekelijkse daling in vier weken. Vanwege de voortdurende verslechtering van de situatie in het Midden-Oosten en de algehele sluiting van het grootste olieveld van Libië, zijn de zorgen over onderbrekingen in de olievoorziening op de markt toegenomen. Als gevolg hiervan sloten de Amerikaanse en Birmaanse olie-markten hoger in de eerste week van dit jaar.</p>
<p>Het is een typisch verschijnsel dat de markt aan het begin van het nieuwe jaar schommelingen ondergaat.</p>
<p>Echter, de dubbele afwaardering van de beoordeling van Apple binnen een week heeft bezorgdheid onder beleggers opgewekt dat de aandelen overgekocht zijn na recente winsten. Het sterke werkgelegenheidsrapport van vrijdag en de onverwachte daling van de ISM-dienstengegevens hebben het rentevooruitzicht nog verwarrender gemaakt. Aangezien de dovish renteverwachtingen altijd een van de belangrijkste drijfveren waren voor het marktherstel tegen het einde van 2023, zullen beleggers de komende week nauwlettend de inflatiegegevens in de gaten houden om te bepalen of de marktverwachtingen al vooruit zijn gegaan. De voortgang van de situatie in de Rode Zee zal ook de krantenkoppen blijven halen.</p>
<p>Aan de andere kant overtrof de werkgelegenheid buiten de landbouw van vorige week de marktverwachtingen en is het ook het vermelden waard.</p>
<p>De werkloosheidsgraad in de VS in december bedroeg 3,7% (vorige waarde: 3,7%; marktverwachting: 3,8%); Na de kwartaalaanpassing in december bedroeg de niet-agrarische werkgelegenheid in de Verenigde Staten 21,6 (vorige waarde: 19,9; marktverwachting: 17) - hoger dan de marktverwachting; Het gemiddelde uurloon steeg met 0,4% (vorige waarde: 0,4%; marktverwachting: 0,3%) - hoger dan de marktverwachting (versnelde salarisgroei).</p>
<p>Vanuit elk perspectief heeft deze gegevens ervoor gezorgd dat de markt zijn inzet op de renteverlaging van de Federal Reserve heeft verlaagd. Op dit moment heeft Wall Street zijn verwachtingen voor een renteverlaging in maart verlaagd en hebben sommige investeringsbanken zelfs vroegtijdig gewaarschuwd dat de eerste renteverlaging rond juni zal plaatsvinden. Dergelijke marktverwachtingen zullen handelaren zeker treffen, dus we moeten goed anticiperen op de vertraagde renteverlaging van de Federal Reserve.</p>
<p>Veel analisten beschouwen de januarimarkt als een barometer van de jaarlijkse trend van de markt (de indicator die in januari wordt gebruikt om toekomstige markttrends te meten heeft een betrouwbaar record), een populaire Wall Street-spreuk die vorig jaar waar bleek te zijn.</p>
<p>Vorig jaar daalde de Amerikaanse dollarkoers in januari, terwijl de Amerikaanse aandelenmarkt, goud en Amerikaanse schatkist obligaties in januari stegen. Uiteindelijk daalde de Amerikaanse dollar het hele jaar door, en de laatste steeg scherp, waardoor een onverwacht jaar ontstond. En dit jaar begon de wereldmarkt met het slechtste record in de geschiedenis, waarbij de wereldwijde obligatie- en aandelenmarkten in slechts één week meer dan $3 biljoen verloren.</p>
<p>De marktwaarde van de zeven grote aandelen die de Amerikaanse aandelenmarkt in 2023 omhoog dreven, verdampte met meer dan $400 miljard, waardoor alle winsten in december teniet werden gedaan. Voor de resterende 20 dagen moeten we zien of de markt kan omdraaien en omhoog kan gaan. Het brengt echter nog steeds enkele moeilijkheden met zich mee. Betekent dit dat het hele jaar 2024 zal blijven in de voetsporen van januari, en moeten we blijven observeren. Wat betreft analisten die letten op de trend van januari, is dit gebaseerd op statistieken van eerdere gegevens, en is het onzeker of de gegevens van dit jaar kunnen aanhouden.</p>
<p>Op 7 januari waarschuwde Federal Reserve Logan dat de Fed mogelijk de korte termijn beleidsrentes moet verhogen om te voorkomen dat de recente daling van de lange termijn obligatierendementen de inflatie weer aanwakkert.</p>
<p>“Als we de financiële voorwaarden niet voldoende strak handhaven, lopen we het risico dat de inflatie weer opveert en de vooruitgang die we hebben geboekt, tenietdoet,” zei Logan. “Beperkende financiële voorwaarden hebben een belangrijke rol gespeeld bij het afstemmen van vraag en aanbod en het handhaven van stabiele inflatieverwachtingen,” zei ze, erop wijzend dat de inflatiepercentages de doelstelling van 2% van de Federal Reserve naderen, en hoewel de arbeidsmarkt nog steeds strak is, is deze aan het herstellen. Als we de financiële voorwaarden niet voldoende strikt handhaven, kunnen we geen prijsstabiliteit verwachten.</p>
<p>De prijsstelling van renteverlagingen op de markt loopt aanzienlijk voor op die van de Federal Reserve, en de rentefutures wijzen momenteel op zes renteverlagingen dit jaar. Vergeleken met de richtlijnen die de Federal Reserve heeft gegeven tijdens de vergadering in december, is dit duidelijk een meer duifachtig standpunt. Volgens de notulen van de vergadering van vorige maand is het mogelijk dat de rentetarieven hun hoogtepunt hebben bereikt, maar beleidsmakers hebben nog niet besproken wanneer ze met renteverlagingen zullen beginnen, en sommige functionarissen sluiten de mogelijkheid van verdere renteverhogingen niet uit. Uit het diagram van de Federal Reserve van december blijkt dat er tegen het einde van 2024 slechts drie renteverlagingen zullen zijn.</p>
<p>Daarom zal verdere vooruitgang in de Amerikaanse inflatie worden gevolgd om het argument te ondersteunen dat prijsdruk wordt gecontroleerd en ruimte te bieden aan beleidsmakers om hun opvattingen over renteverlagingen aan te passen.</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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het plaatsen van het artikel is toegestaan op voorwaarde dat 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>