RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBvdmVyc2NocmVlZCAkIDQ1LjAwMDsgSGV0IGxpcXVpZGF0aWV2b2x1bWUgdmFuIFRSQiB3YXMgaGV0IGhvb2dzdGUgaW4gaGV0IGhlbGUgbmV0d2VyazsgSEZULCBTVUksIEFDQSBlbiBhbmRlcmUgdG9rZW5zIGtyaWpnZW4gZGV6ZSB3ZWVrIGdyb3RlIG9udGdyZW5kZWxpbmdlbg==

2024-01-02, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/17041795201_3.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20BTC20Doorbreekt204500020TRBs20Uitgaande20Volume20Rangschikt20Bovenaan20Alle20Netwerken295148"><a name="Crypto Dagelijks Overzicht: BTC Doorbreekt $45.000, TRB’s Uitgaande Volume Rangschikt Bovenaan Alle Netwerken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: BTC Doorbreekt $45.000, TRB’s Uitgaande Volume Rangschikt Bovenaan Alle Netwerken</h2><p>Op 2 januari plaatste Fox-journalist Eleanor Terrett op het X-platform dat hoewel het gedrag van de Amerikaanse Securities and Exchange Commission (SEC) onvoorspelbaar is, het onwaarschijnlijk is dat spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s zullen de volgende dag worden goedgekeurd. Uit het gesprek met de uitgever bleek dat de SEC nog steeds alle wijzigingen in het op donderdag/vrijdag ingediende S-1 formulier moet bekijken en er commentaar op moet geven.</p>
<p>Als de SEC een soortgelijk goedkeuringsschema volgt als de ETH-futures van oktober, zal het bureau na deze beoordelingsronde met de emittent communiceren over de datum waarop zij het definitieve S-1-formulier willen indienen en het binnen de komende 24-48 uur van kracht willen maken. SEC-medewerkers zijn sinds afgelopen vrijdag op vakantie, dus het lijkt erop dat de tijd dringt als ze dinsdag of woensdag goedkeuring willen.</p>
<p>Eerder verklaarden bronnen van BlackRock dat de SEC mogelijk pas dit weekend <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot-ETF’s kan goedkeuren.</p>
<p>Uit het recente “Blockchain White Paper (2023)”, uitgebracht door de China Academy of Information and Communications Technology, blijkt dat vanaf december 2023 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft ongeveer 7500 knooppunten, waarvan er ongeveer 3400 knooppunten zijn in de Verenigde Staten en ongeveer 1800 knooppunten in Duitsland, goed voor bijna 70% van het totaal.</p>
<p>Vanaf oktober 2023 is het aantal wereldwijde blockchain-unicornbedrijven (met een marktwaarde van meer dan $1 miljard) gestegen tot 131. De top vijf waarderingsranglijsten zijn: Binance ($45 miljard), Upbit ($17 miljard), Ripple ($15 miljard), Blockchain Com ($14 miljard) en OpenSea ($13 miljard).</p>
<p>Volgens een Bitcoin mining rapport uitgegeven door Bankless Times, vertegenwoordigt de rekencapaciteit van de 28 lidstaten van de Europese Unie (EU) in totaal 6% van de rekencapaciteit van het Bitcoin-netwerk. Ierland vertegenwoordigt daarvan 2% van de rekencapaciteit van het Bitcoin-netwerk. De Verenigde Staten zijn momenteel het leidende land op het gebied van Bitcoin mining, met 38% van de rekencapaciteit van het netwerk. China staat momenteel op de tweede plaats met een aandeel van 21%, gevolgd door Kazachstan (13%), Canada (7%) en Rusland (5%) op de derde tot vijfde plaats.</p>
<p>Volgens de monitoring van on-chain analist Yu Jin, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> is de tiende grootste houder van BTC geworden. Op de laatste dag van Q4 bleef <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> BTC-verzoeken indienen van Bitfinex, met in totaal 888,88 BTC-verzoeken ($ 379 miljoen). Op dit moment bezit Tether in totaal 66465,2 BTC’s ($ 2,82 miljard), met uitgebreide kosten van ongeveer $ 25.176 en een zwevende winst van $ 1,148 miljard (+68%).</p>
<p>Op 2 januari, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De nieuwe Meme coin LFG airdrop voor Ethereum-gebruikers werd geopend voor aanvraag. LFG is de eerste Solana-ecosysteem airdrop gericht op Ethereum-gebruikers, met als doel meer Ethereum-gebruikers naar <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> te brengen.</p>
<p>De totale voorraad LFG-tokens is 1 biljoen, waarvan 60% zal worden gebruikt voor airdrops. De kwalificatiecriteria voor de eerste airdrop zijn dat de gasprijs ten minste $4.269 moet zijn voor Ethereum-adressen en dat er interactie moet zijn met ten minste één algemeen Ethereum-protocol. De officiële schatting is dat er in totaal 400 miljard LFG’s zullen zijn. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> naar 387.000 portefeuilleadressen. De portemonnee heeft een maand de tijd om te verzamelen, en niet-geclaimde LFG’s worden na deze periode vernietigd. De tweede airdrop zal worden verdeeld onder de ontvangers van de LP airdrop-portemonnee.</p>
<p>Op 1 januari, volgens de marktgegevens van Gate.io, kende TRB ernstige schommelingen in de afgelopen 24 uur. Het bereikte gisteravond om 20:47 uur een historisch hoogtepunt van $315 en daalde vervolgens met 25% om binnen een korte periode $232 te bereiken. Vervolgens steeg het meer dan 200% in 7 uur en bereikte het een historisch hoogtepunt van $714,55 om 4:26 uur vandaag. Na een lichte consolidatie begon het een scherpe daling en daalde het met 73% in 3 uur. Het wordt nu genoteerd op $270.</p>
<p>Bovendien zijn er sinds de vroege ochtend van vandaag, toen TRB naar een hoog niveau steeg, verschillende gradaties van premies tussen mainstream platforms, evenals tussen spot en contracthandelsparen. Momenteel heeft het Bybit-platform nog steeds een premie van ongeveer 20% in vergelijking met andere platforms.</p>
<p>Volgens Coinglas-gegevens, als gevolg van de drastische schommelingen in TRB-prijzen, bereikte het liquidatievolume in de afgelopen 24 uur $57,78 miljoen, bijna twee keer zo veel als het liquidatievolume van BTC ($24,3 miljoen).</p>
<p>De markt laat zien dat de BTC-prijs de $45.000 heeft overschreden en momenteel wordt gerapporteerd op $45.044,09, met een stijging van 6,02% in de afgelopen 24 uur. In de afgelopen 12 uur werd het hele netwerkcontract verkocht voor $102 miljoen, waarbij short-orders werden verkocht voor $86,7213 miljoen.</p>
<p>Uit gegevens van Coinglass blijkt dat de cryptomarkt in de afgelopen 12 uur in totaal $ 102 miljoen aan cryptocontracten heeft zien verkopen over het hele netwerk, waarbij meerdere orders uitverkocht waren voor $ 15,117 miljoen en korte orders uitverkocht waren voor $ 86,7213 miljoen. Het totale bedrag van de BTC-liquidatie is ongeveer $ 51.2641 miljoen en het totale bedrag van de ETH-liquidatie is $ 13.1526 miljoen.</p>
<p>Volgens Token Unlocks-gegevens zullen deze week HFT, SUI, ACA en andere tokens een eenmalige grote ontgrendeling ervaren, met een totale vrijgave waarde van ongeveer $43.37 miljoen. Onder hen:</p>
<p>Om 7:00 uur (UTC) op 1 januari zal Acala 27,43 miljoen ACAs ontgrendelen (ongeveer $2,95 miljoen), wat overeenkomt met 3,1% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 2 januari zal Sui 34,62 miljoen SUI’s ontgrendelen (ongeveer $26,88 miljoen), wat overeenkomt met 3,35% van het circulerende aanbod;</p>
<p>Om 0:00 uur (UTC) op 5 januari ontgrendelt Galxe 3 miljoen GALs (ongeveer $6,97 miljoen), wat overeenkomt met 3,34% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 7 januari zal Hashflow 13,62 miljoen HFT’s (ongeveer $5,14 miljoen) vrijgeven, wat overeenkomt met 4,81% van het circulerende aanbod; Daarnaast zal HFT vanaf die dag dagelijks 316.200 tokens vrijgeven gedurende 366 dagen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag34794"><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-BTC20BTC730788"><a name="BTC (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/1704179657BTC.png" alt=""><br>De ochtend opende met een voortgezette opwaartse trend en bereikte de eerder gerichte weerstand op $45,345 USD. Het hoogste slot van de ochtend was $45,365 USD, aan de verwachtingen voldaan. Deze week wordt verwacht dat deze rond het hoge bereik van $41,500 USD zal blijven stabiliseren. Op korte termijn kan er een mogelijke ommekeer zijn, waarbij wordt hersteld van de recente daling, met de volgende weerstand op $47,990 USD.</p>
<p>Als ‘momentum-gedreven tijd’ een liquidatie in gehefboomde markten veroorzaakt, kan het eerste kwartaal van dit jaar een terugval zien naar het bereik van $26K tot $28,5K USD. Als ‘tijdgedreven momentum’ leidt tot een geleidelijke daling, kan steun vóór Q2 worden gevonden in het bereik van $36.000 USD tot $33.085 USD.</p>
<h3 id="h3-ETH795046"><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/1704179682ETH.png" alt=""><br>Op korte termijn toont de grafiek van vier uur een tweede poging om te stijgen, waarbij de weerstand op $ 2.381 USD wordt aangeraakt zonder vol te houden. Het korte termijn advies is om de steun op $ 2.332 USD vast te houden. Als een doorbraak boven $ 2.489 USD mislukt, kan er een valse uitbraak gevolgd door een echte daling plaatsvinden. Het lange termijn perspectief blijft positief met doelstellingen op $ 8.000 USD en $ 12.350 USD.</p>
<h3 id="h3-LINK176978"><a name="LINK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LINK</h3><p><img src="https://gimg2.gateimg.com/image/article/1704179768LINK.png" alt=""><br>Op korte termijn heeft de vieruursgrafiek opnieuw nieuwe recente hoogtepunten bereikt. Deze week wordt verwacht dat het blijft schommelen binnen het hoge stijgende kanaalbereik, waarbij op middellange termijn een omkering waarschijnlijk is bij het topvormende hoofd en schouders patroon, met een hoogtepunt op $17,16 USD. Op lange termijn ziet de bullish markt mogelijkheden om $56,02 USD, $79,80 USD en $107,54 USD te doorbreken, met meer dan 7 keer de huidige indelingsruimte.</p>
<h2 id="h2-Macro20De20drie20belangrijkste20aandelenbeurzen20zullen20een20aanzienlijke20stijging20zien20in20202320en20CICC20voorspelt20dat20de20Fed20de20rente20zal20verlagen20in20het20tweede20kwartaal880705"><a name="Macro: De drie belangrijkste aandelenbeurzen zullen een aanzienlijke stijging zien in 2023, en CICC voorspelt dat de Fed de rente zal verlagen in het tweede kwartaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De drie belangrijkste aandelenbeurzen zullen een aanzienlijke stijging zien in 2023, en CICC voorspelt dat de Fed de rente zal verlagen in het tweede kwartaal</h2><p>Afgelopen vrijdag schommelde de Amerikaanse dollarkoers nauwelijks boven het niveau van 101 en sloot uiteindelijk 0,11% hoger op 101,35. Het daalde meer dan 2% in 2023, waarbij het grootste deel van de daling plaatsvond in het vierde kwartaal; Het rendement op Amerikaanse staatsobligaties schommelde en beëindigde de tweejarige opeenvolgende positieve trend. Het rendement op Amerikaanse staatsobligaties met een looptijd van 10 jaar sloot uiteindelijk op 3,866%, iets lager dan het slotniveau van 3,875% in 2022; Het rendement op Amerikaanse staatsobligaties met een looptijd van 2 jaar, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 4,25%, bijna 20 basispunten lager voor het jaar.</p>
<p>Spotgoud beleefde een tweede opeenvolgende dag van daling in de handel, daalde gedurende de dag tot onder $ 2.060 en sloot uiteindelijk 0,15% lager op $ 2.062,94 per ounce. In 2023 steeg het met 13%, de beste jaarprestatie sinds 2020. Spotzilver sloot 0,84% lager op $ 23,79 per ounce.</p>
<p>Ondanks zorgen over de escalatie van de situatie in de Rode Zee, bleef het bearish sentiment op de oliemarkt nog steeds bestaan vanwege de recordproductie van landen buiten OPEC, waarbij WTI-ruwe olie uiteindelijk met 0,95% daalde tot $71,24 per vat; Brent-ruwe olie sloot uiteindelijk met 0,58% lager op $77,19 per vat. Twee oliebedrijven hebben het hele jaar door zwak gepresteerd en zijn meer dan 10% gedaald, wat de eerste jaarlijkse daling sinds 2020 markeert. Amerikaanse aardgasfutures daalden bijna 44% in 2023, wat de grootste jaarlijkse daling sinds 2006 markeert.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen sloten licht lager, maar behaalden allemaal hun negende opeenvolgende week van winst. De Nasdaq daalde met 0,56%, met een cumulatieve stijging van 0,12% vorige week en een cumulatieve stijging van meer dan 43% voor het hele jaar; De S&amp;P 500-index daalde met 0,28%, met een cumulatieve stijging van 0,32% vorige week en een cumulatieve stijging van meer dan 24% voor het hele jaar; De Dow Jones Industrial Average daalde met 0,05%, met een cumulatieve stijging van 0,81% vorige week en een cumulatieve stijging van meer dan 13% voor het hele jaar.</p>
<p>De zeven reuzen van de Amerikaanse aandelenmarkt zagen een aanzienlijke stijging in 2023, waarbij Nvidia bijna 240% steeg voor het jaar, wat de grootste jaarlijkse stijging sinds 2001 markeert; Het moederbedrijf van Facebook, Meta, steeg gedurende het hele jaar met meer dan 194%, wat de grootste jaarlijkse stijging sinds de beursgang markeert; Tesla’s jaarlijkse cumulatieve stijging overschreed 101%.</p>
<p>Onlangs heeft China International Capital Corporation (CICC) een onderzoeksrapport vrijgegeven waarin staat dat, op basis van de laatste ontwikkelingen, wij van mening zijn dat de Federal Reserve de rente in het tweede kwartaal van 2024 wil verlagen, wat een kwartaal eerder is dan onze verwachtingen. De mogelijke veranderingen in het Amerikaanse monetaire beleid weerspiegelen in zekere mate ons eerder benadrukte standpunt dat de Federal Reserve waarschijnlijk zijn inflatietolerantie voor groei zal verhogen.</p>
<p>Het moet echter worden opgemerkt dat vroege renteverlagingen risico’s met zich mee kunnen brengen van economische ‘niet-landing’ en ‘secundaire inflatie’, waardoor de marktvolatiliteit wordt verergerd.</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 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>