RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4taW5zY3JpcHRpZSBnZW1hcmtlZXJkIGFscyBlZW4ga3dldHNiYWFyaGVpZCBpbiBkZSBjeWJlcmJldmVpbGlnaW5nOyAxMCB2ZXJoYWxlbiBkaWUgZGUgYWFuZGFjaHQgd2FhcmQgemlqbiB2YW4gMjAyMy0yMDI0OyBBUFQsIEFQRSBlbiBhbmRlcmUgdG9rZW5zIHp1bGxlbiBpbiBncm90ZSB

2023-12-11, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/17022771091_6-07.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Bitcoin20Inschriften20Gemarkeerd20als20Cybersecurity20Kwetsbaarheden201020Verhalen20die20de20moeite20waard20zijn20om20aandacht20aan20te20besteden20van2020232024729874"><a name="Crypto Dagelijks Overzicht: Bitcoin Inschriften Gemarkeerd als Cybersecurity Kwetsbaarheden, 10 Verhalen die de moeite waard zijn om aandacht aan te besteden van 2023-2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Inschriften Gemarkeerd als Cybersecurity Kwetsbaarheden, 10 Verhalen die de moeite waard zijn om aandacht aan te besteden van 2023-2024</h2><p>Op 9 december heeft de National Vulnerability Database (NVD) van de Verenigde Staten volgens Cointelgraph aangemerkt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> inies als een cybersecurity-risico, waarbij wordt opgeroepen tot aandacht voor beveiligingskwetsbaarheden ontwikkeld door Ordinals Protocol in 2022.</p>
<p>Volgens databasegegevens kunnen in bepaalde versies van Bitcoin Core en Bitcoin Knot beperkingen van gegevensdragers worden omzeild door gegevens te verhullen in code. Opname in de NVD-lijst betekent dat specifieke netwerkbeveiligingskwetsbaarheden zijn geïdentificeerd, gecatalogiseerd en bekend moeten worden gemaakt aan het publiek. Deze database wordt beheerd door het National Institute of Standards and Technology (NIST), een dochteronderneming van het Amerikaanse ministerie van Handel.</p>
<p>Eerder verklaarde Bitcoin Core-clientontwikkelaar Luke Dashjr dat de kwetsbaarheid van de Bitcoin Core-client die werd misbruikt door de inie, is toegewezen aan de identifier CVE-2023-50428.</p>
<p>Op 11 december, volgens The Block met verwijzing naar Etherscan-gegevens, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> bevroor 161 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gisteren zijn er 200 wallets aangemaakt, waarvan 150 wallets momenteel geen USDT bevatten. Het is onbekend of <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> in het verleden USDT heeft bezeten en in welke hoeveelheid. Er zijn in totaal 11 walletadressen die meer dan 3,5 miljoen USDT bevatten, waarvan één adres ongeveer 3,4 miljoen USDT bevat. ZachXBT heeft dit adres in verband gebracht met de recente hacker attack die Stack heeft ondergaan.</p>
<p>Eerder werd gemeld dat Tether gisteren heeft verklaard dat het bedrijf persoonlijke wallets heeft bevroren die zijn gesanctioneerd door het Office of Foreign Assets Control (OFAC) in de Verenigde Staten, met als doel ‘proactief te voorkomen dat Tether-tokens mogelijk verkeerd worden gebruikt en beveiligingsmaatregelen te verbeteren.’ Tether heeft ook verduidelijkt dat bestaande wallets op de OFAC-lijst zullen worden bevroren, en eventuele nieuwe wallets die in de toekomst worden toegevoegd, zullen ook worden bevroren.</p>
<p>Onlangs heeft Binance Labs een rapport uitgebracht waarin de ‘10 meest opmerkelijke verhalen’ worden samengevat. Laten we ze eens bekijken als investeringsreferenties:</p>
<p>Tot nu toe is de totale marktwaarde van cryptocurrencies dit jaar met ongeveer 110% gestegen, wat betekent dat het kapitaal met meer dan $870 miljard is gestegen. Tot nu toe is de markt in het vierde kwartaal met 55% gestegen (ongeveer $596 miljard).</p>
<ol>
<li><p>De voorraad stablecoins herstelt zich en voor het eerst sinds het eerste kwartaal van 2022 is de netto kwartaalverandering in de top vijf stablecoin-voorraden positief geworden.</p>
</li><li><p>De handelsvolume van NFT doorbrak de neerwaartse trend van 8 maanden, met een maand-op-maand stijging van bijna 200% in november; Bitcoin is de meest populaire keten, met NFT-transacties die $375 miljoen overschrijden en zelfs <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> NFT’s ($348 miljoen) overtreffen.</p>
</li><li><p>In november steeg de kostprijs van de top 20 cryptoprojecten met ongeveer 84% ten opzichte van oktober en ongeveer 100% ten opzichte van september. De TVL van DeFi steeg ook, terwijl de dominante positie van DeFi maand op maand met 18% toenam.</p>
</li><li><p>Bitcoin ordinals en BRC-20 hebben opnieuw interesse gewekt in november, en het nieuws over Bitcoin spot ETF’s ziet er optimistisch uit. Verwacht wordt dat de markt goedkeuring zal verkrijgen in januari, en de halvering van Bitcoin in april is nog een belangrijke mijlpaal die de moeite van het volgen waard is.</p>
</li><li><p>Onlangs hebben veel andere ketens van Laag 1 beter gepresteerd dan Ethereum, met opmerkelijke vooruitgang in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>.</p>
</li><li><p>SocialFi heeft nieuwe protocollen geïntroduceerd, zoals friend.tech, evenals updates voor Farcaster, Lens en Binance Square.</p>
</li><li><p>RWA wordt steeds belangrijker en vertegenwoordigt momenteel meer dan 49% van de activa van MakerDAO op de balans; Chainlink hoopt ook een nauwere verbinding tot stand te brengen tussen TradFi, RWA en cryptocurrencies via zijn nieuwe CCIP-oplossing.</p>
</li><li><p>Zero knowledge technologie is in opkomst en er zijn onlangs verschillende ZK-rollups uitgebracht, evenals werk en discussies over ZK-coprocessors toegenomen.</p>
</li><li><p>De Amerikaanse rente staat op het hoogste niveau in 22 jaar en de markt verwacht een renteverlaging volgend jaar.</p>
</li></ol>
<p>Dit weekend begon het NFT blue chip-project, Pudgy Penguins, plotseling in beweging te komen.</p>
<p>Op 10 december kondigde het NFT-project Pudgy Penguins op sociale media aan dat Pudgy Penguins Pudgy World Alpha zal lanceren in Q1 2024, ondersteund door zkSync.</p>
<p>Pudgy World is een interactieve digitale gaminglocatie voor Pudgy Penguins NFT-houders, speelgoedeigenaren en beginners. Pudgy Penguins heeft als doel gebruikers een nieuw tijdperk van door blockchain ondersteunde ervaringen te brengen, met als doel miljoenen mensen aan te trekken. Pudgy World Alpha zal nieuwe personages Pudgy en Peaches introduceren.</p>
<p>Na de bekendmaking, volgens de marktgegevens van Blur, overtrof de bodemprijs van het NFT-project ‘Fat Penguin’ Pudgy Penguins 12 ETH, met een bodemprijs van 12.29 ETH en een stijging van 45.27% in 7 dagen.</p>
<p>Deze week zullen APT, CYBER, APE en andere tokens eenmalig een grote ontgrendeling ontvangen, met een totale release waarde van ongeveer $252 miljoen. Daaronder:</p>
<p>Om 0:00 uur (UTC) op 11 december, <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> ontgrendeld 12,72 miljoen GLMRs (ongeveer $4,31 miljoen), goed voor 1,6% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 12 december, <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> zal 24,84 miljoen APTs ontgrendelen (ongeveer $209 miljoen), wat overeenkomt met 8,9% van de circulerende voorraad;</p>
<p>Op 15 december om 4:19 uur (UTC) ontgrendelt CyberConnect 1,26 miljoen CYBER’s (ongeveer $ 8,71 miljoen), goed voor 8,51% van het circulerende aanbod;</p>
<p>Om 0:00 uur (UTC) op 16 december, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> zal 2,6 miljoen FLOW’s ontgrendelen (ongeveer $2,18 miljoen), wat overeenkomt met 0,18% van de omloopvoorraad;</p>
<p>Om 0:00 uur (UTC) op 17 december, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zal 15,6 miljoen APE’s (ongeveer $28,08 miljoen) ontgrendelen, wat overeenkomt met 4,23% van het circulerende aanbod.</p>
<h2 id="h2-Huidige20belangrijkste20token20trends668832"><a name="Huidige belangrijkste token trends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige belangrijkste token trends</h2><h3 id="h3-BTC356867"><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/1702277172BTC.png" alt=""><br>Afgelopen week markeerde zeven opeenvolgende bullish sluitingen sinds de opening. Het handelsvolume op korte termijn vertoont tekenen van het bereiken van zijn hoogtepunt, in afwachting van een aanzienlijke terugval deze week. Verkoopdoelen op korte termijn: $40.495 en $38.975. Het vasthouden boven $37.980 wordt nog steeds beschouwd als een bullish signaal, maar het oversteken naar beneden vereist aandacht, omdat dit kan duiden op een verschuiving van een bullish naar een bearish trend.</p>
<h3 id="h3-ETH314893"><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/1702277191ETH.png" alt=""><br>De opwaartse beweging van vorige week naderde de doellijn op $2.381 en bereikte een hoogtepunt van $2.386. Als er een marktbrede correctie optreedt, verwacht dan een test van de ondersteuning op $2.135. Boven $1.951 blijven, zelfs tijdens een terugval, duidt nog steeds op een bullish trend. Op korte termijn kunnen er zowel korte als lange posities mogelijk zijn.</p>
<h3 id="h3-INJ110993"><a name="INJ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>INJ</h3><p><img src="https://gimg2.gateimg.com/image/article/1702277214INJ.png" alt=""><br>De dagelijkse grafiekstructuur is gestegen van het dieptepunt van $ 1.225 naar de historische weerstand van $ 24.999. Deze week zal naar verwachting de weerstand meerdere keren uitdagen en nieuwe hoogtepunten bereiken met doelen op $ 37.828, $ 61.084 en $ 97.616. Deze drie niveaus worden beschouwd als voorwaarden voor het ontstaan van een langdurige bullmarkt.</p>
<h2 id="h2-Macro20CPI20sluit20zich20aan20bij20terroristische20data20aanvallen20en20deze20week20zal20de20Federal20Reserve20de20toon20zetten20voor202024711813"><a name="Macro: CPI sluit zich aan bij “terroristische data” aanvallen, en deze week zal de Federal Reserve de toon zetten voor 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI sluit zich aan bij “terroristische data” aanvallen, en deze week zal de Federal Reserve de toon zetten voor 2024</h2><p>Het vrijdagse niet-agrarische rapport wees erop dat de Amerikaanse arbeidsmarkt heter en veerkrachtiger was dan Wall Street had verwacht, waardoor de marktverwachtingen werden ondermijnd dat de Federal Reserve de rente al in maart volgend jaar zou verlagen, terwijl het ook het standpunt ondersteunde dat de Federal Reserve een zachte landing kon bereiken.</p>
<p>De Amerikaanse aandelenmarkt slaagde er ternauwernood in om zijn wekelijkse stijging vast te houden, waarbij de Amerikaanse dollarindex voor het eerst in een maand op rij steeg en de Amerikaanse obligatierendementen terugkeerden naar hun opwaartse trend. Onder de dubbele druk van de stijgende rente op de Amerikaanse dollar en Amerikaanse obligaties, versnelde goud zijn daling van historische hoogtepunten. Spotgoud daalde voor het eerst in twee weken onder de grens van $ 2.000, terwijl goudfutures daalden tot het laagste niveau in bijna twee weken, de eerste opeenvolgende wekelijkse daling in een maand.</p>
<p>Ruwe olie bleef de hele week dalen, wat de langste opeenvolgende daling in vijf jaar markeerde. Op vrijdag herstelden de olieprijzen zich van een dieptepunt van vijf maanden, toegeschreven aan een gezamenlijke verklaring van de Russische president Poetin en de Saudische kroonprins Salman na hun ontmoeting, waarin het belang van voortgezette samenwerking en de noodzaak voor alle OPEC+ landen om zich te houden aan het protocol werd benadrukt. Maar er zijn nog steeds veel negatieve factoren, waaronder een onverwachte stijging van de benzinevoorraden in de Verenigde Staten vorige week en een daling van 9% in de ruwe olie-import van China in november.</p>
<p>Vooruitkijkend naar volgende week zullen de Federal Reserve, de Bank of England en de Europese Centrale Bank op dezelfde dag hun definitieve renteresoluties voor het jaar bekendmaken, met een onmiskenbaar gewicht. Naast deze drie grote centrale banken zullen volgens de statistieken de komende dagen, binnen een tijdsbestek van 60 uur, meerdere economieën die goed zijn voor 60% van de wereldeconomie de rentetarieven vaststellen, waaronder Zwitserland, Noorwegen, Brazilië, Mexico, Rusland en anderen. Voor en na Super Thursday zal de markt ook zwaargewicht gegevens ontvangen, zoals het Amerikaanse CPI-rapport van november, “terroristische gegevens” en de PMI van de Europese en Amerikaanse productie, waardoor de complexiteit van de markt wordt vergroot.</p>
<p>Daarbij zal het rapport van de Amerikaanse CPI van volgende week en het rentebesluit van de Federal Reserve de toon zetten voor de markt en economie in 2024. Gezien de intensiteit van risico-evenementen zullen handelaren voor aanzienlijke uitdagingen komen te staan.</p>
<p>Mensen verwachten over het algemeen dat de Federal Reserve haar referentierentevoet op het hoogste niveau in 20 jaar zal handhaven, omdat besluitvormers de achterblijvende impact van een reeks agressieve renteverhogingen sinds begin 2022 ueren.</p>
<p>Het is vermeldenswaard dat aan het begin van deze vergadering de functionarissen van de Federal Reserve toegang hadden tot het onlangs uitgebrachte Amerikaanse CPI-rapport van november, dat volgende week dinsdag wordt gepubliceerd. De kern-CPI wordt verwacht het standpunt te versterken dat de inflatie alleen geleidelijk afneemt. Powell zal tijdens een persconferentie de vooruitgang erkennen die is geboekt op het gebied van inflatie en de risico’s bespreken die worden veroorzaakt door hardnekkige prijsdruk. Verschillende economen van Bloomberg hebben verklaard dat de Federal Reserve niet haastig zal zijn om de rentetarieven te verlagen om verdere versoepeling van de financiële omgeving te voorkomen.</p>
<p>Nick Timiraos, een bekende journalist met de bijnaam ‘New Federal Reserve News Agency’ en nu bekend als ‘Nikileaks’ op Wall Street, publiceerde echter een belangrijk artikel op een cruciaal moment, vlak voordat de Federal Reserve deze week zijn nieuwste rentebesluit zal nemen.</p>
<p>Hij concludeerde in het artikel dat functionarissen van de Federal Reserve deze week waarschijnlijk niet serieus zullen bespreken wanneer ze de rentetarieven moeten verlagen, en het misschien de komende maanden niet zullen bespreken, tenzij de economische zwakte de verwachtingen overtreft. Hij noemde de geschiedenis van de Federal Reserve waarbij de rentetarieven ongeveer zes maanden na de laatste renteverhoging werden verlaagd, evenals de aanzienlijke fout van de Federal Reserve om te vroeg renteverlagingen door te voeren.</p>
<p>De laatste rentevoorspelling wordt echter verwacht te laten zien dat de meeste ambtenaren volgend jaar een renteverlaging verwachten.</p>
<p>In feite is de volgende renteverhoging van de Federal Reserve niet langer ons aandachtspunt. Ons aandachtspunt ligt op de renteverlaging van volgend jaar. Vanaf nu zal de renteverlaging van volgend jaar ongetwijfeld meer dan slechts één of twee keer plaatsvinden.</p>
<p>Daarom zijn er vanaf nu drie belangrijke gebeurtenissen voor de cryptocurrency-industrie volgend jaar. Ten eerste zal de soepele goedkeuring van Bitcoin spot ETF’s plaatsvinden; Ten tweede is de verwachting van een renteverlaging van de Federal Reserve stevig gevestigd; Ten derde nadert de Bitcoin-halvering.</p>
<p>De combinatie van de bovenstaande drie gebeurtenissen zal uitmonden in een grote positieve ontwikkeling, waarbij de komst van een bullmarkt in deze cyclus wordt waargenomen.</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 is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>