RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZWVmdCB6aWx2ZXIgb3ZlcnRyb2ZmZW4gZW4gaXMgZGUgb3AgZWVuIG5hIGdyb290c3RlIGNvbW1vZGl0eSBFVEYtYWN0aXZhIGluIGRlIFZlcmVuaWdkZSBTdGF0ZW4gZ2V3b3JkZW47IEluc3RlbGxpbmdlbiB2b29yc3BlbGxlbiBkYXQgRVRIIEJUQyBrYW4gb3ZlcnRyZWZmZW4gaW4gaGV0IG1

2024-01-19, 04:01

<p><img src="https://gimg2.gateimg.com/image/article/17056368111_16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht202020Bitcoin2020overtreft20zilver20en20wordt20de20op20n20na20grootste20grondstof20in20de20Verenigde20Staten20zal202020Ethereum2020Bitcoin20inhalen370701"><a name="Crypto Dagelijks Overzicht:   Bitcoin  overtreft zilver en wordt de op één na grootste grondstof in de Verenigde Staten, zal   Ethereum  Bitcoin inhalen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> overtreft zilver en wordt de op één na grootste grondstof in de Verenigde Staten, zal <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> inhalen?</h2><p>Volgens gegevens van Capital15C is de omvang van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s zijn snel uitgebreid, waaronder onlangs genoteerde spot Bitcoin ETF’s, met een totale waarde van $ 27,9 miljard, wat overeenkomt met 647.651 BTC’s, waarvan Grayscale ongeveer 600000 BTC’s bezit. Volgens etfdb.com omvat de activaklasse “Broad Diversified” 22 ETF’s met een AUM van $ 12,826 miljard. Op de derde plaats staat zilver, dat vijf ETF’s omvat met een AUM van $ 11,546 miljard. Hoewel BTC momenteel niet op zijn ETF-lijst staat, staat Bitcoin, als het in de toekomst wordt toegevoegd, op de tweede plaats in de AUM-berekening en is het de op één na grootste grondstof in de Verenigde Staten geworden.</p>
<p>Cathie Wood, oprichter en CEO van ARK Investment Management, zei in een interview dat ze gelooft dat een Bitcoin op een dag $1 miljoen waard zou kunnen zijn, maar niet heel binnenkort. Goud is een vermogensobject ter waarde van biljoenen dollars, en we geloven dat Bitcoin hier enorm van zal profiteren.</p>
<p>Cathie Wood legde uit hoe Bitcoin een prijs van $1 miljoen per munt kan bereiken, waarbij ze stelt dat deze vergelijking niet alleen waarde omvat, maar ook de fundamentele rol die Bitcoin kan spelen als een gedecentraliseerd en privé-alternatief voor traditionele valuta. Bovendien speelt Bitcoin een cruciale rol in opkomende markten, omdat het bescherming kan bieden tegen instabiel monetair en fiscaal beleid van individuen en instellingen. De meeste opkomende markten zullen dingen als Bitcoin gebruiken als verzekering.</p>
<p>Wood is van mening dat Bitcoin een nieuw tijdperk in de financiën vertegenwoordigt - het eerste wereldwijde, digitale en gedecentraliseerde valutasysteem. Dit is een doorbraak, vooral gezien de sluiting van het Amerikaanse goudvenster in 1971.</p>
<p>Nadat de Bitcoin spot ETF was goedgekeurd, heeft het de laatste tijd hoge regelgevende aandacht getrokken van landen over de hele wereld.</p>
<p>Gisteren verklaarde Sherrod Brown, voorzitter van de Senaatscommissie bankwezen, dat de commissie in de komende weken het witwassen van geld in de crypto-industrie opnieuw zal onderzoeken. Brown voegde eraan toe dat het nog moet blijken of de besproken beleidsmaatregelen zullen worden geïmplementeerd als een reeks onafhankelijke wetsvoorstellen of als een pakket wetsvoorstellen.</p>
<p>Op woensdag hebben EU-beleidsmakers een tijdelijke overeenkomst bereikt over een deel van een allesomvattend regelgevingsplan om witwassen van geld te bestrijden, waardoor alle cryptobedrijven due diligence kunnen uitvoeren bij hun klanten. De Anti Money Laundering Regulations (AMLR) zijn een allesomvattende inspanning om sanctie-ontduiking en witwassen van geld te bestrijden. Het omvat het creëren van een enkel regelboek en het oprichten van een regelgevend orgaan dat ook regelgevende bevoegdheid zal hebben over de cryptosector.</p>
<p>Gisteren heeft een woordvoerder van de Monetaire Autoriteit van Singapore verklaard dat de Collectieve Beleggingsregelingen (CIS) waarin Singaporese particuliere beleggers kunnen deelnemen, worden gereguleerd door de Securities and Futures Act en ETF’s omvatten. De typen activa waarin ze kunnen beleggen zijn beperkt. Momenteel zijn Bitcoin en andere digitale betalingstokens (cryptocurrencies) (DPT’s) geen in aanmerking komende activa voor CIS voor particuliere beleggers. Daarom staat de Monetaire Autoriteit van Singapore niet toe dat dergelijke financiële producten in Singapore worden genoteerd en zich richten op particuliere beleggers, aangezien cryptocurrencies zoals Bitcoin niet worden vermeld als in aanmerking komende activa voor ETF’s.</p>
<p>Op 19 januari wezen analisten van JPMorgan erop dat als GBTC-investeerders doorgaan met het terugwinnen van winst, de Bitcoin-prijzen mogelijk verdere neerwaartse druk zullen ondervinden in de komende weken, volgens The Block. Na de conversie van GBTC naar een Bitcoin ETF op de spotmarkt vorige week, is er meer dan $1,5 miljard aan kapitaal uitgestroomd. JPMorgan Chase schatte uiteindelijk dat de uitstroom van gelden uit GBTC zou kunnen oplopen tot $3 miljard, voornamelijk als gevolg van mogelijke winstneming door investeerders.</p>
<p>Volgens het laatste marktupdate-rapport van QCP Capital kan de goedkeuring van spot ETH ETF’s door de marktverwachtingen komen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zal naar verwachting blijven overtreffen in de middelste bullmarkt. ‘We verwachten dat <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> op middellange termijn Bitcoin blijft overtreffen, omdat de marktaandacht zich richt op mogelijke goedkeuringen van ETH spot ETF,’ zei een analist bij QCP Capital.</p>
<p>Het marktupdate-rapport van QCP Capital van woensdag wees er ook op dat de wisselkoers ETH/BTC in de afgelopen week is gestegen van 0,05 naar 0,06. Het rapport voegde eraan toe: “De volgende belangrijke crypto-evenementen zullen de halvering van Bitcoin in medio april en mogelijke goedkeuringen van spot Ethereum ETF’s vanaf mei zijn.”</p>
<p>Op donderdag heeft de SEC de uiteindelijke deadline voor het nemen van een beslissing over de plek van Fidelity Ethereum Bitcoin uitgesteld. De nieuwe deadline is 5 maart. De SEC verklaarde: “het comité is van mening dat het noodzakelijk is om een langere periode aan te wijzen om actie te ondernemen met betrekking tot de voorgestelde regelwijziging, om voldoende tijd te hebben om de voorgestelde regelwijziging en de daarin gerezen kwesties te overwegen.”</p>
<p>Bloomberg-analist James Seyfhart zei: ‘Deze stap is volledig in lijn met de verwachtingen, en naar mijn mening is de werkelijk belangrijke datum eind mei.’ Volgens eerdere nieuwsberichten heeft Fidelity in november vorig jaar een aanvraag ingediend voor een Ethereum spot ETF.</p>
<h2 id="h2-Macro20De20arbeidsmarkt20blijft20stabiel20de20Fed20kan20de20rente20niet20verlagen20vr20het20derde20kwartaal270294"><a name="Macro: De arbeidsmarkt blijft stabiel, de Fed kan de rente niet verlagen vóór het derde kwartaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De arbeidsmarkt blijft stabiel, de Fed kan de rente niet verlagen vóór het derde kwartaal</h2><p>Op donderdag registreerde het aantal eerste werkloosheidsuitkeringen in de Verenigde Staten voor de week eindigend op 13 januari 187.000, het laagste sinds de week eindigend op 24 september 2022.</p>
<p>Vanwege gegevens die aantonen dat de arbeidsmarkt stabiel bleef en de marktverwachtingen voor de renteverlaging van de Federal Reserve onderdrukte, fluctueerde de Amerikaanse dollarkoers omhoog en breidde zijn winsten uit vóór de Amerikaanse markt. Het steeg kortstondig tot een hoogtepunt van 103,62 gedurende de dag en sloot uiteindelijk 0,04% hoger, wat de vijfde opeenvolgende handelsdag van winst op 103,41 markeerde; Het rendement op Amerikaanse obligaties blijft stijgen. Het rendement op Amerikaanse staatsleningen van 10 jaar bleef boven de 4,1%, en sloot uiteindelijk af op 4,142%; Het rendement op Amerikaanse staatsleningen van 2 jaar, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot af op 4,354%.</p>
<p>Spot goud herstelde zich en sloot op twee opeenvolgende gehele niveaus tijdens de Amerikaanse sessie, uiteindelijk met een stijging van 0,85% op $ 2023,23 per ounce. Spot zilver sloot uiteindelijk met een stijging van 0,85% op $ 22,75 per ounce.</p>
<p>Internationale ruwe olie blijft zijn opwaartse trend voortzetten. WTI-ruwe olie steeg aanzienlijk tijdens de Amerikaanse sessie en bereikte kortstondig een intraday hoogtepunt van $ 74,16, uiteindelijk 1,55% hoger te sluiten op $ 73,80 per vat; Brent-ruwe olie steeg met 1,17% tot $ 78,92 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices openden hoog en sloten hoog. De Dow Jones Industrial Average steeg met 0,54%, de S&amp;P 500-index steeg met 0,88% en de Nasdaq steeg met 1,35%.</p>
<p>Op donderdag, tijdens een evenement georganiseerd door de Atlanta Business Chronicle, kwam FOMC’s lid van het monetaire beleidsstemmingscomité Bostic naar voren om zijn standpunt te uiten. Het statement van Bostic van de Federal Reserve suggereert dat als de inflatie vertraagt, het het beste is om de rentetarieven voor een langere periode hoog te houden, en als het sneller gaat, er mogelijk een vroegtijdige renteverlaging kan zijn. Hij gaf ook aan te willen zien dat er meer bewijs is dat de inflatie zich naar het 2% doel van de Federal Reserve beweegt. Op dit moment verwacht hij niet dat beleidsmakers de rentetarieven voor het derde kwartaal zullen verlagen.</p>
<p>Mijn huidige vooruitzichten zijn dat we onze eerste renteverlaging in het derde kwartaal van dit jaar zullen hebben, en we zullen beslissen op basis van de voortgang van de gegevens”, zei Bostek eerder op donderdag. Hij voegde eraan toe dat als de inflatie veel sneller daalt dan hij had verwacht, hij bereid zal zijn om snel actie te ondernemen. De slechtste uitkomst zou zijn dat besluitvormers de rente verlagen, waarna de inflatie weer stijgt, waardoor ze uiteindelijk gedwongen worden de rente opnieuw te verhogen.</p>
<p>Volgens de Federal Reserve Observation van CME is de waarschijnlijkheid dat de Federal Reserve de rentetarieven in februari handhaaft in het bereik van 5,25% -5,50% 97,4%, en de waarschijnlijkheid van een renteverlaging van 25 basispunten is 2,6%. De waarschijnlijkheid van handhaving van de rentetarieven ongewijzigd tegen maart is 42,9%, de waarschijnlijkheid van een cumulatieve renteverlaging van 25 basispunten is 55,7%, en de waarschijnlijkheid van een cumulatieve renteverlaging van 50 basispunten is 1,4%.</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 beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>