RGFnZWxpamtzIG5pZXV3cyB8IEdCVEMgYmxpamZ0IGRlIGhvb2dzdGUgaGFuZGVsc3ZvbHVtZXMgYmVob3VkZW47IEdvb2dsZSBzdGFhdCBjcnlwdG8tYWR2ZXJ0ZW50aWVzIHRvZTsgSW5zdGVsbGluZ2VuIHZvb3JzcGVsbGVuIGRhdCBkZSBwcmlqcyB2YW4gQlRDIG5hIGhhbHZlcmluZyBpbiBhcHJpbCAkIDE3MEsgemFsIGJlcmVpa2V

2024-01-30, 03:56

<p><img src="https://gimg2.gateimg.com/image/article/17065869401_23.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Op20de2012e20dag20van20de20handel20in20ETFs20staat20GBTC20nog20steeds20op20de20eerste20plaats20Google20staat20toe20dat20crypto20advertenties20worden20geplaatst479014"><a name="Crypto Dagelijks Overzicht: Op de 12e dag van de handel in ETF’s staat GBTC nog steeds op de eerste plaats, Google staat toe dat crypto advertenties worden geplaatst" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Op de 12e dag van de handel in ETF’s staat GBTC nog steeds op de eerste plaats, Google staat toe dat crypto advertenties worden geplaatst</h2><p>Op 30 januari, volgens gegevens samengesteld door Bloomberg-analist James Seyfart, bedroeg het totale handelsvolume van de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Op de 12e handelsdag bedroeg de handelsomzet van spot-ETF’s 1,5643 miljard dollar. Onder hen was de handelsomzet van GBTC 570 miljoen dollar, wat op de eerste plaats stond, gevolgd door IBIT van BlackRock en FBTC van Fidelity. De cumulatieve handelsomzet van Bitcoin-spot-ETF’s na 12 dagen lancering bereikte 25,9384 miljard dollar.</p>
<p>Op 29 januari heeft Grayscale volgens Lookonchain monitoring 6.534 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC) ter waarde van ongeveer $274,95 miljoen gestort in Coinbase Prime, 25 minuten geleden. Sinds de goedkeuring van de ETF heeft Grayscale in totaal 119.663 Bitcoins gestort in Coinbase Prime, met een totale waarde van ongeveer $4,91 miljard.</p>
<p>Op 30 januari, volgens de dagelijkse positie-update uitgebracht door Grayscale, daalde de Bitcoin-holdings van GBTC onder de 500.000, met een specifiek aantal van 496.573,8166 Bitcoins in bezit, een vermogensbeheerschaal (niet GAAP) van $21.431.132.778,35, en 555.700.100 circulerende aandelen, met een positie van ongeveer 0,0008936 BTC per aandeel.</p>
<p>Volgens Bitcoin Magazine heeft Google zijn advertentiebeleid bijgewerkt om het adverteren van crypto trust-producten in de Verenigde Staten toe te staan. Advertenties voor Bitcoin spot ETF’s zoals BlackRock, VanEck en Franklin Templeton zijn al verschenen op Google zoekpagina’s.</p>
<p>Op 29 januari deed Anthony Scaramucci, oprichter van Skybridge Capital, een optimistische voorspelling over de mogelijke trend van Bitcoin. Op basis van historische gegevens gelooft hij dat de ‘conservatieve’ stijging van Bitcoin in de komende maanden meer dan 300% zal zijn en dat het na de halvering in april een hoogtepunt van $170.000 kan bereiken.</p>
<p>Anthony Scaramucci voorspelt ook dat op de lange termijn de prijs van Bitcoin $400.000 zou kunnen bereiken en de marktwaarde ervan tien keer zou kunnen toenemen, waarmee het de helft van de marktwaarde van goud zou benaderen. Op basis van zijn ervaring en analyse zal de piek van de Bitcoin-prijzen ongeveer 18 maanden na het halveringsevenement plaatsvinden. Hij voorspelt dat de ‘cyclische piek’ van Bitcoin equivalent kan zijn aan vier keer de prijs bij halvering.</p>
<p>Scaramucci schat conservatief in dat de prijs van Bitcoin $35.000 zal zijn wanneer gehalveerd, en schetst mogelijke scenario’s: als de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> als het in april $50.000 bereikt, kan het daarna $200.000 bereiken; als het in april $60.000 bereikt, kan het stijgen naar $240.000.</p>
<p>Op 29 januari is volgens The Block TD Cowen Investment Bank van mening dat de Amerikaanse SEC niet wordt verwacht goed te keuren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Spot ETF’s in 2024. Bedrijven zoals BlackRock en Fidelity hebben een aanvraag ingediend voor <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF spot-handel. Vorige week heeft de Amerikaanse SEC opnieuw de beslissing over Grayscale Investments Ethereum ETF spot uitgesteld, en andere aanvragen werden ook eerder deze maand vertraagd. TD Cowen Investment Bank voorspelt dat de Amerikaanse SEC spot Ethereum ETF’s pas zal goedkeuren tegen het einde van 2025 of begin 2026.</p>
<p>Wat betreft gegevensschommelingen, volgens de nieuwste gegevens van Nansen 2, is de 24-uurs Ethereum-netto instroomtrackinglijst van Smart Money als volgt: LDO: ongeveer $3,33 miljoen, momenteel genoteerd op $3,1, een daling van 2,02% in 24 uur; BIGTIME: Ongeveer $990.000, momenteel genoteerd op $0,3605, met een daling van 5,55% in 24 uur; UNI: Ongeveer $950.000, momenteel genoteerd op $5,981, met een daling van 0,99% in 24 uur.</p>
<p>Ten tweede heeft de TVL van Eigenpie, een subDAO-organisatie onder het multi-chain-inkomstenprotocol Magpie, de $70 miljoen overschreden. Eerder verklaarde Eigenpie dat het een LST-pre-stortingsvenster heeft geopend, waarbij gebruikers worden ondersteund om opnieuw stETH, rETH, mETH en sfrxETH te staken. Het pre-stortingsvenster blijft open tot 3:00 op 10 februari, en andere LST-stortingen die worden ondersteund door EigenLayer zullen binnenkort worden geactiveerd via Eigenpie.</p>
<h2 id="h2-Macro20Goud20bereikte20bijna20een20week20een20nieuw20hoogtepunt20focus20op20de20rentebesluit20van20deze20donderdag50794"><a name="Macro: Goud bereikte bijna een week een nieuw hoogtepunt, focus op de rentebesluit van deze donderdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Goud bereikte bijna een week een nieuw hoogtepunt, focus op de rentebesluit van deze donderdag</h2><p>Op maandag bereikte de Amerikaanse dollarindex een nieuw hoogtepunt sinds de rentevergadering van de Federal Reserve vorige maand, maar nam toen een scherpe wending en stond op het punt om alle winsten van de dag op te geven. Uiteindelijk sloot hij 0,014% hoger op 103,47; Omdat het Amerikaanse ministerie van Financiën onverwacht de verwachting van de leenschaal voor het eerste kwartaal verlaagde, daalden de rendementen van Amerikaanse obligaties over de hele linie, geleid door het rendement van langlopende schatkistobligaties, en het rendement van 10-jarige Amerikaanse obligaties sloot uiteindelijk op 4,076%; Het rendement van de Amerikaanse staatsobligaties met een looptijd van twee jaar, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,322%.</p>
<p>Vanwege de toenemende spanningen in het Midden-Oosten is de vraag naar veilige haven activa gestegen. Spotgoud opende hoog en fluctueerde naar boven, met een maximum van 2037,41, en sloot uiteindelijk 0,71% hoger op $2032,88 per ounce, waarmee het bijna een week lang een nieuw hoogtepunt bereikte. Spotzilver sloot uiteindelijk 1,78% hoger op $23,2 per ounce.</p>
<p>Internationale ruwe olie opende hoog en daalde laag, daalde tot bijna twee maand hoogtes, eindigend een drie-daagse reeks van winsten. Zorgen over Aziatische vraag leidden handelaren om de risicopremie van spanningen in het Midden-Oosten te heroverwegen. WTI ruwe olie daalde met 1.5% tot $76.88 per vat; Brent ruwe olie daalde met 1.47% tot $82.41 per vat. De daling van de Amerikaanse obligatierendementen versterkte de kracht van de drie belangrijkste Amerikaanse aandelenindexen in de late handelssessie, met de Dow Jones Industrial Average 0.59% hoger, de S&amp;P 500 Index 0.76% hoger, en de Nasdaq 1.1% hoger.</p>
<p>Deze week is het vermeldenswaard dat om 2 uur ‘s ochtends Beijing-tijd op donderdag investeerders zich zullen richten op het laatste rentebesluit van de Federal Reserve. Voorzitter van de Federal Reserve, Powell, zal om 2:30 uur een persconferentie houden.</p>
<p>Hoewel wordt verwacht dat de Federal Reserve de rentetarieven ongewijzigd zal handhaven, kan Powell signalen geven over wanneer de rentetarieven te verlagen en de omvang van toekomstige verlagingen. Beleggers verwachten momenteel dat de Federal Reserve de rentetarieven zes keer met 25 basispunten zal verlagen in 2024, maar de Fed heeft alleen richtlijnen gegeven voor drie renteverlagingen voor die tijd. Er is een aanzienlijk verschil tussen de twee, en naarmate de verwachtingskloof tussen beleggers en de Federal Reserve kleiner wordt, zal dit invloed hebben op de markt.</p>
<p>JoséTorres, senior econoom bij Yingtou Securities, zei dat het huidige niveau van economische groei, in combinatie met een krappe arbeidsmarkt en inflatie boven het streefcijfer, het overgangsproces van het monetair beleid langer en riskanter kan maken, en marktdeelnemers hebben nu de verwachtingen van de eerste renteverlaging van de Federal Reserve in maart of mei achter zich gelaten.</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 zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>