RGFnZWxpamtzIG5pZXV3cyB8IE1pY3JvU3RyYXRlZ3kgdmVyd2llcmYgb3BuaWV1dyAxNC42MjAgQml0Y29pbnM7IEV0aGVyZXVtIExheWVyIDIgZW4gTFNELWVjb3N5c3RlZW1wcm9qZWN0ZW4gc3RpamdlbiBvdmVyIGhldCBhbGdlbWVlbjsgTUVUSVMgc3RlZWcgbWVlciBkYW4gMjAlIGJpbm5lbiDDqcOpbiBkYWc=

2023-12-28, 06:04

<p><img src="https://gimg2.gateimg.com/image/article/17037460411_20.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20MicroStrategy20heeft20opnieuw201462020Bitcoins20verworven20Ethereum20Layer20220en20LSD20Ecoprojecten20stimuleren20over20het20algemeen184918"><a name="Crypto Daily Digest: MicroStrategy heeft opnieuw 14.620 Bitcoins verworven, Ethereum Layer 2 en LSD Eco-projecten stimuleren over het algemeen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: MicroStrategy heeft opnieuw 14.620 Bitcoins verworven, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Layer 2 en LSD Eco-projecten stimuleren over het algemeen</h2><p>De bekendste grootste walvis van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, MicroStrategy, heeft opnieuw zijn bezittingen verhoogd.</p>
<p>Michael Saylor, uitvoerend voorzitter van MSTR, onthulde op het X-platform dat MicroStrategy opnieuw 14.620 Bitcoins heeft verworven voor $615,7 miljoen, met een gemiddelde prijs van $42.110. Per 26 december 2023 heeft MicroStrategy momenteel 189.150 BTC’s in bezit en verwerft ze voor ongeveer $5,9 miljard, met een gemiddelde prijs van $31.168.</p>
<p>Met harmonieus gezang uitte Cathie Wood een positieve en optimistische houding ten opzichte van de goedkeuring van de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF.</p>
<p>Volgens Benzinga heeft Cathie Wood, oprichter en CEO van Ark Invest, onlangs een interview gegeven aan CNBC. Met betrekking tot de spot Bitcoin ETF ‘ARK 21SHARES BITCOIN ETF’, gezamenlijk gelanceerd door ARK Invest en 21 Shares, verklaarde ze dat de Amerikaanse Securities and Exchange Commission haar ‘kennisdiepte’ van cryptocurrencies heeft verbeterd en mogelijk de ingediende spot Bitcoin ETF vóór 10 januari 2024 zal goedkeuren.</p>
<p>Daarnaast benadrukte Wood ook het belang van ETF’s bij het stimuleren van institutionele interesse in het crypto-veld. Zodra instellingen en investeerders zich gevestigd hebben, zullen ze manieren zoeken om hun beleggingsportefeuilles te diversifiëren. Bij het bespreken van de impact van goedkeuringen van spot ETF’s op de prijs van Bitcoin, verklaarde Wood dat dit een korte-termijn impact zal hebben. Ze gelooft echter dat de promotie van institutionele Bitcoin een significante impact zal hebben op de prijzen van toonaangevende cryptocurrencies.</p>
<p>In reactie hierop weerlegde Max Keiser, senior adviseur van de president van El Salvador, de verklaring van Cathie Wood op sociale media dat “als Bitcoin spot ETF’s worden goedgekeurd, ze meer instellingen zullen aantrekken om binnen te komen”, en verklaarde dat deze verklaring misleidend is. Alle Bitcoin spot ETF’s die met contant geld zijn gemaakt, zijn slechts proxy-tools voor beleggers om BTC-prijzen te volgen en kunnen geen daadwerkelijke BTC verkrijgen.</p>
<p>Hierover hebben ETF-analisten van Bloomberg verklaard dat als Bitcoin ETF’s alleen in contanten kunnen worden gecreëerd, in plaats van BTC (in fysieke vorm gecreëerd), dan zullen de meeste niet-crypto-individuen (vooral vermogensbeheerinstituten die $33 biljoen aan activa beheren) niet veel te maken hebben. In feite geven ze er de voorkeur aan om er dollars mee te verdienen, ze willen er gewoon aan worden blootgesteld.</p>
<p>Op 28 december, volgens Bloomberg, daarbij verwijzend naar insiders, is het liquide tokenfonds van Pantera Capital dit jaar met bijna 80% gestegen, na een daling van 80% in 2022. Het mobiele tokenfonds van Pantera Capital hoopt Altcoins (andere tokens dan Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>) om volgend jaar een stijging te bereiken.</p>
<p>Cosmo Jiang, een portefeuillemanager bij Pantera, zei in een interview dat na de opkomst van Bitcoin, Altcoins altijd beter hebben gepresteerd dan de markt in de tweede fase van het herstel, en de keuze van token eigenlijk belangrijk is. Zijn beperkte partners vragen ons om activa buiten Bitcoin te verkopen.</p>
<p>En het kernargument van Pantera is dat als we geloven dat deze industrie zich zal ontwikkelen, we ons moeten richten op protocollen die daadwerkelijk inkomsten kunnen genereren. Momenteel is een van de grootste posities van Pantera Capital <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, met Bitcoin en Ethereum goed voor minder dan 40% van het totale fonds.</p>
<p>Onlangs heeft Li Haolong, voorzitter van de Greater Bay Area Capital Group, tijdens de Guangdong Hong Kong Macao Greater Bay Area Digital Economy Development Conference aangekondigd dat de Greater Bay Area Capital Group (GBA Capital) de lancering van een Web3.0-industriefonds ter waarde van 10 miljard yuan zal aankondigen om te investeren in wereldwijd gerelateerde sectoren zoals yuan-activa, metaverse, NFT, RWA, enzovoort, om de Guangdong Hong Kong Macao Greater Bay Area te helpen uitgroeien tot ‘s werelds hoofdstad van yuan-activa.</p>
<p>Naar verluidt werden er ook meerdere ondertekeningsceremonies gehouden op de conferentie, waarbij Greater Bay Area Capital Group, het organisatiecomité van de conferentie, en meerdere partners contracten ondertekenden. In de toekomst zal worden samengewerkt op gebieden als digitale economie, meta-activa, Web 3.0 en metaverse.</p>
<p>Op 28 december plaatste Grayscale officieel op sociale media dat ETH sterke rendementen (meer dan 80%) heeft gegenereerd in 2023, maar dat de prestaties achterbleven bij BTC en sommige andere smart contract blockchain tokens. De verhouding tussen de ETH- en BTC-prijsindices heeft recentelijk het laagste niveau bereikt sinds medio 2021.</p>
<p>In feite is de groeisnelheid van de meeste smart contract platform tokens dit jaar lager dan die van Bitcoin, en ETH is in wezen consistent met deze vergelijkbare groep. De CryptoSector-index van FTSE’s grayscale smart contract platform steeg met ongeveer 94% in 2023, slechts iets hoger dan de stijging van ETH. Hoewel ETH achterloopt op Bitcoin en sommige andere crypto-activa in 2023, overtreft het nog steeds traditionele activaklassen. Daarom geloven we dat de heropleving van ETH gezien moet worden als bewijs van de uitbreiding van cryptoherstel.</p>
<p>Op 28 december, volgens de laatste Gate.io markt, bereikte Ethereum kortstondig $2.400 en wordt nu genoteerd op $2.399,55, met een stijging van 7,63% in 24 uur.</p>
<p>Volgens L2BEAT-gegevens kan de Metis Andromeda-netwerk TVL worden beïnvloed door de stijging van de muntprijzen, en bereikt het $695 miljoen, met een stijging van 560% in 7 dagen. Het staat momenteel op de derde plaats in de Ethereum Layer 2-netwerk TVL, met een verschil van minder dan $1 miljoen in vergelijking met de derde gerangschikte Base-netwerk TVL ($696 miljoen).</p>
<p>Op 27 december, volgens de marktgegevens van Gate.io, bereikte METIS $90 en wordt nu genoteerd aan $90,7, met een dagelijkse stijging van 20,8% en een stijging van 155% in 4 dagen.</p>
<p>Beïnvloed door Vitalik’s artikel waarin drie methoden worden voorgesteld om de berichtenkant van Ethereum’s POS-mechanisme te vereenvoudigen, zag het Layer 2-project token op 27 december een algemene opwaartse trend, waarbij OP in 24 uur met 19,38% steeg en nu voor $3,92 wordt genoteerd; MATIC heeft een stijging van 18,34% in 24 uur en wordt momenteel genoteerd op $1,06; METIS heeft een stijging van 17,1% in 24 uur en wordt momenteel genoteerd op $86,71; ARB is in 24 uur met 10,74% gestegen en wordt nu genoteerd op $1,48.</p>
<p>Op 28 december zag LSD protocol governance tokens ook een algemene stijgende trend, met LDO momenteel genoteerd op $2,83, een toename van 16,8% in 24 uur; PENDLE wordt momenteel genoteerd op $1,2706, met een toename van 14,37% in 24 uur; SSV wordt momenteel genoteerd op $26,4, met een toename van 12,74% in 24 uur; en RPL wordt momenteel genoteerd op $32,3, met een toename van 12,2% in 24 uur.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag413327"><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-BTC357104"><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/1703746246BTC.png" alt=""><br>Deze week heeft een aanhoudende hoge volatiliteit gezien, met nog een opwaartse beweging richting belangrijke niveaus vanochtend. Weerstandsniveaus hierboven zijn $45.345 en $47.990, terwijl steunniveaus hieronder liggen op $41.450 en $40.280. Tekenen van convergentie op het hoogste punt suggereren een mogelijke marktbeslissing medio volgende maand.</p>
<h3 id="h3-ETH802101"><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/1703746260ETH.png" alt=""><br>Er is een kortetermijn omgekeerd hoofd-en-schouderpatroon van vier uur ontstaan, wat wijst op een bullish trend. Op korte termijn is het cruciaal om boven $2.489 te blijven, waarbij de strategie aanhoudende winsten laat zien vanaf $2.180. De neerwaartse steun is verschoven naar een sleutelniveau van $2.381.</p>
<h3 id="h3-GT730009"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/1703746274GT.png" alt=""><br>De wekelijkse grafiek markeert het begin van de tweede fase van een bullish markt, met een duidelijke opwaartse trend. De korte termijn vier-uur grafiek blijft convergentie tonen, in afwachting van een vroege bullish uitbraak in de platformmuntsector. Richtprijzen zijn $12.877, $18.977, $28.58 en $44.99. Langetermijnpositionering wordt aanbevolen.</p>
<h2 id="h2-Macro20De20Amerikaanse20dollarindex20is20naar20een20nieuw20dieptepunt20gedaald20kan20202420het20jaar20worden20van20renteverlagingen55097"><a name="Macro: De Amerikaanse dollarindex is naar een nieuw dieptepunt gedaald, kan 2024 het jaar worden van renteverlagingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Amerikaanse dollarindex is naar een nieuw dieptepunt gedaald, kan 2024 het jaar worden van renteverlagingen?</h2><p>Op woensdag versnelde de Amerikaanse dollar-index zijn daling tijdens de Amerikaanse markt en daalde onder het niveau van 101, waardoor een nieuw laagste niveau werd bereikt sinds juli van dit jaar. Uiteindelijk sloot het met een daling van 0,6% op 100,94; Het rendement op Amerikaanse schatkistpapier is sterk gedaald, waarbij het rendement op 10-jaars schatkistpapier onder de 3,8% grens is gedaald en uiteindelijk sloot op 3,789%. Het rendement op tweejaars schatkistpapier, dat gevoeliger is voor het rentetariefbeleid van de Federal Reserve, sloot op 4,240%.</p>
<p>Spotgoud zette zijn opwaartse trend voort, doorbrak het niveau van 2080 tijdens de Amerikaanse markt en bereikte een intradayhoogtepunt van $2084.49, waarmee het bijna drie weken lang een nieuw hoogtepunt bereikte. Het slaagde er echter niet in om boven het niveau van 2080 te stabiliseren en sloot uiteindelijk 0.47% hoger op $2077.07 per ounce; Spotzilver steeg 0.18% en sloot af op $24.27 per ounce.</p>
<p>Nu wereldwijde scheepvaartbedrijven op het punt staan terug te keren naar de Rode Zee, hebben de twee oliemaatschappijen bijna de winsten van gisteren uitgewist. WTI ruwe olie daalde aanzienlijk op de Europese markt, viel onder de $75 en daalde naar een intraday laag van $73,78, uiteindelijk sloot deze met een verlies van 2% op $73,78 per vat; Brent ruwe olie slaagde er niet in om boven de $80 te stabiliseren en sloot uiteindelijk met een verlies van 1,72% op $79,24 per vat.</p>
<p>De belangrijkste Amerikaanse aandelenindexen sloten iets hoger, met de Dow Jones 0,3% hoger, de S&amp;P 500 0,14% hoger en de Nasdaq 0,16% hoger. Aandelen in digitale valutaconcepten leidden de markt omhoog, waarbij MicroStrategy (MSTR. O) meer dan 11% steeg als gevolg van positieve factoren uit MSTR’s toegenomen bezit in Bitcoin.</p>
<p>Onlangs hebben enquêtes van verschillende regionale Federal Reserve-banken, waaronder New York en Dallas, aangetoond dat Amerikaanse werkgevers verwachten dat ze in 2024 de werving zullen verminderen, wat naar verwachting de loongroei zal beperken en de inflatiedruk zal verlichten. De gegevens tonen aan dat de maatregelen van de Federal Reserve gericht op het vertragen van de economische groei en het beteugelen van de inflatie van invloed zijn op de economie, wat betekent dat er sprake is van een vertraging in de werkgelegenheid maar niet van een directe inkrimping.</p>
<p>Naarmate de tijd verstrijkt en we 2024 ingaan, zijn renteverlagingen een belangrijk trefwoord geworden in het beleid van de Federal Reserve. Ondertussen zal naarmate we het nieuwe jaar ingaan, ook de lijst met functionarissen met stemrecht bij de FOMC-vergadering van de Federal Reserve veranderen.</p>
<p>Het Federal Open Market Committee (FOMC) van de Federal Reserve bestaat uit twaalf leden en houdt jaarlijks acht vergaderingen om economische en financiële omstandigheden te bespreken en te stemmen over het passende monetaire beleid om de taken van het maximaliseren van werkgelegenheid en het stabiliseren van prijzen te bereiken.</p>
<p>Gedurende hun ambtstermijn hebben de zeven leden van de Raad van Bestuur van de Federal Reserve permanente stemrechten en kunnen zij bij elke vergadering een cruciale stem uitbrengen; Als financieel centrum van de Verenigde Staten is New York de meest economisch ontwikkelde en financieel actieve plaats in het land, dus de voorzitter van de Federal Reserve van New York heeft ook permanente stemrechten. De overige 11 regionale voorzitters van de Federal Reserve delen 4 stemrechten en rouleren jaarlijks. Functionarissen zonder stemrecht zijn ook verplicht om vergaderingen bij te wonen en deel te nemen aan discussies.</p>
<p>In 2024 bestaat het roterende stemcomité, naast functionarissen met permanente stemrechten, uit Atlanta Fed-voorzitter Bostic, San Francisco Fed-voorzitter Daley, Cleveland Fed-voorzitter Mester en Richmond Fed-voorzitter Barkin. De lijst met leden van het roterende stemcomité verandert jaarlijks en heeft daardoor de grootste invloed op de stemming.</p>
<p>Over het algemeen heeft Waller’s houding een duidelijke verschuiving naar een ‘duifachtige houding’ laten zien, terwijl in het roterende stemcomité van 2024 de trend van een ‘duifachtige houding’ nog luider lijkt te zijn. Bij het betreden van het jaar van renteverlagingen kan zo’n ‘havikachtige en duifachtige combinatie’ de Federal Reserve vaardiger maken.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>