RGFnZWxpamtzIG5pZXV3cyB8IERlIFNFQyBrYW4gbW9nZWxpamsgYWwgem8gdnJvZWcgYWxzIGFhbnN0YWFuZGUgZGluc2RhZyBCaXRjb2luIFNwb3QgRVRGJ3MgZ29lZGtldXJlbjsgWktCYXNlIHN0YWF0IG9wIGhldCBwdW50IGVlbiAxOjEtdG9rZW5ydWlsIHRlIGltcGxlbWVudGVyZW47IFRSQiwgU0lMTFkgZW4gT1JESSBzY2hpZXR

2024-01-01, 02:09

<p><img src="https://gimg2.gateimg.com/image/article/17040832451_2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20SEC20kan20mogelijk20al20vanaf20deze20dinsdag20Bitcoin20spot20ETFs20goedkeuren20TRB20SILLY20en20ORDI20schieten20omhoog674854"><a name="Crypto Dagelijkse Samenvatting: De SEC kan mogelijk al vanaf deze dinsdag Bitcoin spot ETF’s goedkeuren; TRB, SILLY en ORDI schieten omhoog" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De SEC kan mogelijk al vanaf deze dinsdag <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s goedkeuren; TRB, SILLY en ORDI schieten omhoog</h2><p>Het is de eerste dag van 2024, Gelukkig nieuwjaar voor iedereen!</p>
<p>Ten eerste komt de langverwachte ETF binnenkort. Volgens Reuters, die zich beroept op bronnen die bekend zijn met de zaak, als ze ervoor kiezen om goed te keuren. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Voor spot-ETF’s kunnen ze de uitgever al in de loop van dinsdag of woensdag van deze week op de hoogte brengen.</p>
<p>Gisteren, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Oprichter Vitalik Buterin tweette een bijgewerkte routekaart voor de ontwikkeling van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> in 2023. De routekaart omvat voornamelijk zes onderdelen: The Merge, The Surge, The Scourge, The Verge, The Purge en The Spluge. “The Merge”, voltooid in september 2022, markeert de verschuiving van Ethereum van PoW naar PoS consensusmechanisme, wat de energieconsumptie van het netwerk aanzienlijk vermindert. Ondertussen heeft “The Surge” aanzienlijke vooruitgang geboekt. De cross-rollup standaard en interoperabiliteit worden ook beschouwd als gebieden die op lange termijn verbetering vereisen.</p>
<p>Bovendien benadrukte Buterin dat de rol van Single Slot Final Determinism (SSF) bij het verbeteren van PoS na de fusie wordt geconsolideerd en het is de eenvoudigste manier om veel huidige zwaktes in het Ethereum PoS-ontwerp aan te pakken.</p>
<p>Wat betreft het ZK-traject, volgens officiële rapporten heeft het Layer 2 volledig uitgeruste protocol ZKBase (eerder bekend als ZKSpace) op basis van ZK Rollups de vernietiging van 400 miljoen tokens voltooid (wat overeenkomt met 40% van het totale ZKS), waardoor het niet uitgegeven bedrag van ZKS is gedaald van 440 miljoen naar 40 miljoen, met een deflatiepercentage van meer dan 90%. In combinatie met de doorlopende platformvernieuwing terugkoop en vernietiging, is het totale bedrag van ZKS gedaald van 1 miljard naar minder dan 600 miljoen, en de overgebleven tokens zullen worden gebruikt voor toekomstige operationele activiteiten en community-incentives.</p>
<p>In 2024 heeft het team plannen om ZKSwap (Bitcoin) voor BRC20 en Bitcoin tokens te lanceren en ZKS te upgraden naar ETH en BTC dual chain Layer2 governance tokens. Eerder heeft het ZKBase-team de merkupgrade aangekondigd naar ZKBase, inclusief het omwisselen van ZKS1:1 voor ZKB, dat het nieuwe governance-token van het ZKBase-team zal worden. Tokenhouders kunnen genieten van verschillende voordelen zoals ERC20-BRC20 cross chain voordelen en 100% transactiekosten.</p>
<p>Het toekomstige team zal het Layer2-ecosysteem van ETH en BTC verder ontwikkelen en een deel van de ZKS-tokens naar het BTC-netwerk migreren. De voordelen die voortvloeien uit de migratie zullen ook volledig worden gebruikt voor continue terugkoop en vernietiging van tokens, en om de plannen voor tokendeflatie te versnellen.</p>
<p>Volgens Dune-gegevens heeft de cumulatieve omzet van de Ordinals Inion van het Bitcoin NFT-protocol 5238.0058 BTC’s bereikt, wat equivalent is aan ongeveer $218.359.158. Het huidige totale aantal gietinies bereikt 52.651.648.</p>
<p>Wat betreft marktfluctuaties wordt Teller Tributees (TRB) momenteel verhandeld op $282,81, met een stijging van 16,66% in de afgelopen 24 uur; <a href="/price/kadena-kda" rel="nofollow noopener noreferrer" target="_blank">Kadena</a> (KDA) rapporteert momenteel $1.37, met een stijging van 19.6% in 24 uur; Silly Dragon (SILLY) handelt momenteel op $0.139, een stijging van 11% in 24 uur; ORDI (ORDI) handelt momenteel op $82.36, met een stijging van 9.4% in 24 uur.</p>
<p>Echter kwam de terugval ook snel. Coinglass-gegevens tonen aan dat TRB-contracten in de afgelopen 24 uur $ 59,9364 miljoen hebben verkocht, waarbij meerdere orders $ 19,1616 miljoen hebben verkocht en short orders $ 40,7748 miljoen hebben verkocht.</p>
<p>De markt laat zien dat TRB snel is gestegen, en eerder $600 heeft doorbroken op de korte termijn, en vervolgens een aanzienlijke terugval heeft ervaren. Momenteel staat het op $208,31, 20,2% lager in 24 uur; SILLY wordt momenteel gerapporteerd op $0,132, terwijl ORDI (ORDI) momenteel wordt gerapporteerd op $81,10.</p>
<p>Volgens The Block wordt het cross-chain bridging protocol Orbit Chain verdacht van hacking, waardoor er een abnormale uitstroom van cryptocurrency ter waarde van $81,5 miljoen plaatsvond. In vijf afzonderlijke transacties stuurde Orbit Bridge $50 miljoen stablecoins (30 miljoen USDT’s, 10 miljoen DAIs en 10 miljoen USDC’s), 231 wBTC’s (ongeveer $10 miljoen) en 9500 ETH’s (ongeveer $21,5 miljoen).</p>
<p>Gebruiker Kgjr was de eerste die het hackgedrag opmerkte, en de exacte aard van de hackaanval is nog onduidelijk. Volgens PeckShield-bewaking heeft de aanvaller aanvankelijk 10 ETH’s opgehaald van Tornado Cash en deze via een tussenadres dat begint met 0x704 overgedragen.</p>
<p>Volgens de statistieken van CertiK hebben veiligheidsincidenten op het gebied van crypto in december in totaal $33,5 miljoen aan verliezen veroorzaakt, waaronder ongeveer $3,2 miljoen aan verliezen door exit scams, ongeveer $2,4 miljoen aan verliezen door flash loan-aanvallen en ongeveer $27,8 miljoen aan verliezen door exploit-incidenten.</p>
<h2 id="h2-Macro20In20de20eerste20week20van20202420staan20de20nonfarm20payroll20en20de20vergaderingen20van20de20Federal20Reserve20op20het20punt20om20het20oudejaarsavond20af20te20trappen446881"><a name="Macro: In de eerste week van 2024 staan de non-farm payroll en de vergaderingen van de Federal Reserve op het punt om het oudejaarsavond af te trappen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: In de eerste week van 2024 staan de non-farm payroll en de vergaderingen van de Federal Reserve op het punt om het oudejaarsavond af te trappen</h2><p>De transactie voor 2023 eindigde zo. De prijs van New York goudtermijncontracten steeg gedurende het jaar met meer dan 13%, wat de grootste jaarlijkse stijging sinds 2020 markeerde. De verwachting van de markt dat de Federal Reserve de rentetarieven al in maart volgend jaar zal verlagen, heeft de goudprijzen doen stijgen.</p>
<p>In 2023 kende New York goud futures een dieptepunt van bijna $1,800 en een recordhoogte van $2,135.40. Beleggers verwachten dat de goudprijs in 2024 een historisch hoogtepunt zal bereiken, aangezien de markt over het algemeen een duifachtige verschuiving in het beleid van de Federal Reserve verwacht, voortdurende geopolitieke risico’s, en aankopen van goud door centrale banken om de goudmarkt te ondersteunen.</p>
<p>De Amerikaanse dollarindex daalde in 2023 met meer dan 2%, de grootste jaarlijkse daling sinds 2020. Als gevolg van steeds meer mensen die wedden dat de Federal Reserve de rente in 2024 zal verlagen, ondervond de Amerikaanse dollar een aanzienlijke daling in het vierde kwartaal, wat de aantrekkelijkheid ervan verzwakte omdat andere centrale banken mogelijk voor een langere periode hogere rentetarieven zullen handhaven. Swap-handelaren verwachten momenteel dat de Federal Reserve de rente met minimaal 150 basispunten zal verlagen, waarbij de renteverlagingen al in maart beginnen. De recente daling van de Amerikaanse dollar geeft echter aan dat er nog ruimte is voor een tijdelijk herstel.</p>
<p>De jaarlijkse daling van ruwe olie bedraagt ongeveer 10%, waarmee de opwaartse trend van twee opeenvolgende jaren wordt doorbroken. Deze verschuiving kan worden toegeschreven aan een tumultueus jaar, met geopolitieke spanningen, productiebeperkingen en een daling van de mondiale inflatie die de tegenwinden voor ruwe olie benadrukken, die naar verwachting in de nabije toekomst verder zullen verzwakken. Beleggers moeten de situatie nog steeds nauwlettend volgen. De Amerikaanse aardgasfutures daalden bijna 44% in 2023, wat de grootste jaarlijkse daling sinds 2006 markeert.</p>
<p>In de eerste week van het nieuwe jaar zal de markt zwaargewichtgegevens verwelkomen zoals niet-agrarische loonlijsten, notulen van de Federal Reserve-vergadering en PMI voor de verwerkende industrie en de dienstensector in Europa en Amerika.</p>
<p>De notulen van de vergadering van het Federal Open Market Committee (FOMC) kunnen de bereidheid van de Federal Reserve om de rente in het eerste kwartaal te verlagen onthullen. Bij die vergadering gaven functionarissen aan te hinten naar het beëindigen van de radicale renteverhoging. De Federal Reserve heeft zijn referentierente op het hoogste niveau sinds 2001 gehandhaafd en er wordt niet verwacht dat deze verder zal worden verhoogd. Uit de kwartaalprognoses blijkt dat functionarissen van de Federal Reserve verwachten dat de rente volgend jaar met 75 basispunten zal worden verlaagd. De aankomende notulen zullen meer details verstrekken over de bovenstaande beslissing.</p>
<p>Als de verwachting van de Federal Reserve om de rente in het eerste kwartaal te verlagen wordt geconsolideerd, kan dit de Amerikaanse dollar verder onderdrukken en de goudprijs doen stijgen. Het is het vermelden waard dat goud vaak goed presteert in de eerste maand van elk jaar. Sinds 1971 bedraagt het gemiddelde rendement op goud in januari 1,79%. Gedurende dezelfde periode behaalde goud bijna 60% van de tijd positieve rendementen in januari.</p>
<p>Terug in 2000 behaalde goud rendementen in 70% van januari. Naast de invloed van de Federal Reserve zal de vraag naar goud toenemen na het ingaan van het Chinese Nieuwjaar. Als de historische trend onveranderd blijft, is de kans groot dat goud blijft stijgen tot de eerste maand van 2024. Dit betekent dat dit mogelijk een goede koopkans is.</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 enkele beleggingssuggestie.<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 wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>