RGFnZWxpamtzIG5pZXV3cyB8IEFtZXJpa2FhbnNlIG1pbmlzdGVyaWUgdmFuIEp1c3RpdGllIHJlYWdlZXJ0IG9wIENaLWluY2lkZW50OyBCbGFzdCBNb2RlIHdlcmQgaW4gdHdpamZlbCBnZXRyb2trZW4gZG9vciBWQy1pbnN0ZWxsaW5nZW47IERZRFgsIDFJTkNIIGVuIGFuZGVyZSB0b2tlbnMgemllbiBkZXplIHdlZWsgZ3JvdGUgb25

2023-11-27, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17010667511_27.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Het20Amerikaanse20ministerie20van20Justitie20reageert20op20het20CZincident20Het20Blastmodel20werd20in20twijfel20getrokken20door20VCinstellingen677884"><a name="Crypto Daily Digest: Het Amerikaanse ministerie van Justitie reageert op het CZ-incident; Het Blast-model werd in twijfel getrokken door VC-instellingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Het Amerikaanse ministerie van Justitie reageert op het CZ-incident; Het Blast-model werd in twijfel getrokken door VC-instellingen</h2><p>Laten we eerst de voortgang van het CZ-incident in de gaten houden. Op 26 november reageerde het Amerikaanse ministerie van Justitie op de verklaring van het CZ-verdedigingsteam in de laatste gerechtelijke documenten dat ze een “korte” straf tegemoet gaan en geen motief hebben om te ontsnappen. De regering heeft duidelijk gesteld dat CZ volgens strafrechtelijke richtlijnen kan worden veroordeeld tot maximaal 18 maanden gevangenisstraf en dat openbare aanklagers een maximale wettelijke straf van 10 jaar kunnen eisen.</p>
<p>In het document wordt vermeld dat CZ, hoewel hij familiebanden heeft en niet gevangen is genomen, de straf die hij te wachten staat een aanzienlijke impact op hem zal hebben. Op basis hiervan is de Amerikaanse overheid van mening dat de voorgestelde maatregelen om CZ’s reizen te beperken tijdens de bekentenis en veroordeling redelijk en noodzakelijk zijn, met als doel ervoor te zorgen dat CZ binnen de VS juridische verantwoordelijkheid kan nemen en het mogelijke risico op ontsnapping kan verminderen.</p>
<p>Het Layer 2 Network Blast contractadres, gelanceerd door Pacman, de oprichter van BLUR, het meest populaire NFT-platform van de afgelopen tijd, heeft momenteel een totale activawaarde van meer dan $500 miljoen.</p>
<p>Daarvan werd $439 miljoen aan ETH gestort in het Lido-protocol en $61,81 miljoen in het Maker-protocol. En met dit soort gegevens, dit patroon en de groeiende vragen in de huidige gemeenschap, is het duidelijk dat projecten met CX-patronen aanzienlijke onbekende risico’s met zich meebrengen totdat ze daadwerkelijk worden geïmplementeerd. Zelfs Paradigm, een bekende VC-firma die heeft geïnvesteerd in Blast, kan niet stilzitten.</p>
<p>Dan Robinson, Partner en Onderzoeksdirecteur van Paradigm, verklaarde onlangs op sociale media dat Paradigm het niet eens is met de beslissing van Blast om zijn brug te activeren vóór het Layer 2-netwerk en opnames gedurende drie maanden te verbieden, en gelooft dat dit slechte voortekenen heeft gebracht voor andere projecten en dat de meeste verkoopactiviteiten de efficiëntie van serieuze teams zullen verminderen.</p>
<p>Robinson verklaarde dat Paradigm hun zorgen aan het Blast-team heeft geuit, maar dat er nog steeds veel meningsverschillen zijn, maar Paradigm zal zijn verantwoordelijkheid in het ecosysteem serieus nemen.</p>
<p>Het X-account van de oprichter van een ander populair SocialFi-project, Friend.tech, kan niet worden weergegeven. Volgens de analyses van de gemeenschap wordt vermoed dat het X-account @0xRacerAlt van Friend.tech-oprichter Racer is geannuleerd en momenteel als “niet-bestaand” wordt weergegeven. Volgens DefiLlama-gegevens daalde Friend.tech TVL naar $33,2 miljoen, een daling van meer dan 36% ten opzichte van zijn historische hoogtepunt van $52,04 miljoen op 2 oktober.</p>
<p>Volgens nieuwsberichten. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, na twee keer vorige week te zijn gestegen tot meer dan $18 per transactie, is de transactiekosten van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> gedaald. Op 24 november bedraagt de gemiddelde kosten per transactie ongeveer $5.89, en de mediane kosten per overboeking zijn $2.86. In oktober ontvingen mijnwerkers $885 miljoen aan beloningen en kosten.</p>
<p>Tot 25 november 2023 hebben miners in totaal $945 miljoen verdiend, inclusief transactiekosten en subsidies. Tot 16:00 uur Eastern Time op zaterdag, exclusief subsidies, hebben miners alleen al $124,98 miljoen aan kosten verzameld. Dit aantal komt dicht in de buurt van het recordbedrag van $125,92 miljoen aan transactiekosten uit 2023 dat in mei is behaald.</p>
<p>Volgens de gegevens van Token Unlocks zullen deze week 9 projecten tokens ontgrendelen, met een totale waarde van meer dan $600 miljoen. Onder hen:</p>
<p>Dydx (DYDX) zal naar verwachting ongeveer 152 miljoen tokens ter waarde van ongeveer $520 miljoen ontgrendelen in de komende zeven dagen, wat overeenkomt met 84,41% van de circulerende voorraad;</p>
<p>Sui (SUI) zal naar verwachting ongeveer 82,42 miljoen tokens ter waarde van ongeveer $52,34 miljoen ontgrendelen in de komende zeven dagen, wat overeenkomt met 8,54% van het circulerende aanbod;</p>
<p>Om 16:00 (UTC) op 30 november, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>(OP) zal ongeveer 24,16 miljoen tokens ter waarde van ongeveer $43,73 miljoen ontgrendelen, wat overeenkomt met 2,74% van het circulerende aanbod;</p>
<p>Om 12:00 uur (UTC) op 1 december, <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> (1INCH) zal naar verwachting ongeveer 98,74 miljoen tokens ter waarde van ongeveer $35,03 miljoen ontgrendelen, wat overeenkomt met 9,48% van de circulerende voorraad;</p>
<p>Op 27 november om 14:00 (UTC) zal Yield Guild Games (YGG) ongeveer 16,69 miljoen tokens ter waarde van ongeveer $6,27 miljoen ontgrendelen, wat overeenkomt met 5,48% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 29 november zal Nym (NYM) naar verwachting ongeveer 25 miljoen tokens ter waarde van ongeveer $3,91 miljoen ontgrendelen, wat overeenkomt met 4,1% van de circulerende voorraad;</p>
<p>Om 0:00 uur (UTC) op 28 november zal SingularityNET (AGIC) ongeveer 9,39 miljoen tokens ter waarde van ongeveer $2,9 miljoen ontgrendelen, wat overeenkomt met 0,76% van de circulerende voorraad;</p>
<p>Op 1 december om 7:00 uur (UTC) zal Acala (ACA) ongeveer 27,43 miljoen tokens ter waarde van ongeveer $1,62 miljoen vrijgeven, wat overeenkomt met 3,31% van de circulerende voorraad;</p>
<p>Om 12:00 (UTC) op 3 december, Tornado Cash ( <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a>) ontgrendelt ongeveer 175.000 tokens ter waarde van ongeveer $665.000, wat overeenkomt met 4,62% van de circulerende voorraad.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag923066"><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-BTC133755"><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/1701066789BTC.png" alt=""><br>De wekelijkse trend zet zich voort met zes opeenvolgende weken van winst, wat wijst op tekenen van een mogelijke vertraging. Binnen het convergerende driehoekspatroon worden twee mogelijke scenario’s geschetst: een uitbraak boven $37.980 met doelen op $40.500 en $42.015, of een bearish beweging die de uptrend doorbreekt, met voorzichtigheid rond het niveau van $40.000 om verstoring van de marktstructuur te voorkomen.</p>
<h3 id="h3-ETH466560"><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/1701066809ETH.png" alt=""><br>De 4-uur grafiek breekt boven een belangrijke neerwaartse trend uit en vormt een kortetermijn bodempatroon. Als bearish structuren standhouden, is een hertest van $1.857 mogelijk. Aggressieve bearish posities moeten voorzichtig zijn bij weerstand. Bullish trendvolgers wachten op een doorbraak van weerstand, met als doel $2.135, met een potentieel doelwit van $2.381.</p>
<h3 id="h3-KP3R930845"><a name="KP3R" class="reference-link"></a><span class="header-link octicon octicon-link"></span>KP3R</h3><p><img src="https://gimg2.gateimg.com/image/article/1701066828KP3.png" alt=""><br>Het toonaangevende DeFi-protocol KP3R is met 96,45% gedaald van zijn all-time high van $2.065, met een significante ondersteuningsniveau op $40,05. Het vertrek van de oprichter van het project komt overeen met marktsignalen van mogelijke ommekeer. Deze week wordt verwacht dat het blijft terugtrekken tot $64,05 en $52,98, met een langetermijnstrategie gericht op een terugkeer naar eerdere hoogtepunten.</p>
<h2 id="h2-Macro20Verwachtingen20van20renteverlagingen20kunnen20de20goudprijs20verder20opdrijven20Focus20op20de20kernPCEgegevens20voor20deze20donderdag203327"><a name="Macro: Verwachtingen van renteverlagingen kunnen de goudprijs verder opdrijven; Focus op de kern-PCE-gegevens voor deze donderdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Verwachtingen van renteverlagingen kunnen de goudprijs verder opdrijven; Focus op de kern-PCE-gegevens voor deze donderdag</h2><p>Gedurende de verkorte handelsweek vanwege de Thanksgiving-vakantie in de Verenigde Staten blijven investeerders optimistisch dat de Federal Reserve de rente niet verder zal verhogen en mogelijk in de eerste helft van 2024 de rente zal verlagen.</p>
<p>Met de uitbreiding van de marktbreedte zijn alle drie de belangrijkste Amerikaanse aandelenindices voor de vierde opeenvolgende week gestegen en wordt verwacht dat ze hun beste maandprestatie in meer dan een jaar zullen behalen. Goud sloot boven de kritieke $2.000-markering, wat de tweede opeenvolgende week van winst markeert.</p>
<p>Aan de andere kant, als gevolg van de vrijlating van enkele gijzelaars in de Gazastrook, waardoor de geopolitieke risicopremie daalde, daalden de olieprijzen op vrijdag. Toen de OPEC+-vergadering echter besloot tot het protocol voor productievermindering voor 2024, zagen de olieprijzen nog steeds hun eerste wekelijkse stijging in meer dan een maand.</p>
<p>In de komende week, met het aankomende belangrijke Amerikaanse inflatierapport en OPEC+vergadering, wordt verwacht dat de marktvolatiliteit volgende week opnieuw zal intensiveren.</p>
<p>De laatste toespraken van verschillende functionarissen van de Federal Reserve, waaronder Powell, voor de stille periode zullen in het middelpunt van de belangstelling van de markt komen te staan. Uit de laatste notulen van de vergadering van de Federal Reserve blijkt dat beleidsmakers collectief van mening zijn dat het passend is de rentetarieven ongewijzigd te laten, wat hun voorzichtigheid en bereidheid bevestigt om het beleid verder te verkrappen in het g van onverwachte opwaartse inflatie.</p>
<p>De reactie van de markt hierop was flauw, vrijwel zeker dat de Federal Reserve haar renteverhogingscyclus heeft beëindigd, maar functionarissen zijn niet bereid dit expliciet te verklaren voordat ze er zeker van zijn dat de inflatie niet zal herstellen. De swapcontracten die gekoppeld zijn aan de vergaderperiode van de Federal Reserve blijven aangeven dat de mogelijkheid van verdere renteverhogingen door de Federal Reserve bijna nul is. Volgens de FedWatch-tool van de Chicago Mercantile Exchange is de kans dat de Federal Reserve de rente vóór mei volgend jaar verlaagt, licht toegenomen van ongeveer 57% voordat de notulen van de vergadering werden vrijgegeven tot ongeveer 64%.</p>
<p>Phillip Streible, Chief Market Strategist bij Blue Line Futures, verklaarde dat als gevolg van zwakke gegevens die deze week zijn vrijgegeven, de Federal Reserve zou moeten verschuiven naar een meer duifachtige houding, wat zou leiden tot een verslechtering van de prestaties van de Amerikaanse dollarkoers en mogelijk een positieve factor zou kunnen worden voor de goudprijzen. De Duitse commerciële bank schreef in een rapport dat de stijging van de goudprijzen te wijten is aan de hoop dat de Federal Reserve de rente niet verder zal verhogen, aangezien de laatste economische gegevens nogal teleurstellend zijn. Ondertussen is de bank van mening dat het huidige opwaartse potentieel van goud beperkt lijkt te zijn, aangezien haar economen verwachten dat de eerste renteverlaging in het midden van volgend jaar zal worden doorgevoerd, wat betekent dat pas dan goud boven de $2.000 kan blijven.</p>
<p>Volgende week kunnen er zowel goed als slecht nieuws zijn over de Amerikaanse economische gegevens. De vastgoedmarkt zal het begin van de week in de gaten houden. Op woensdag wordt verwacht dat het verwachte geannualiseerde bbp-groeipercentage voor het derde kwartaal licht zal stijgen van 4,9% naar 5,0%. De sterke groei van de Amerikaanse economie in het derde kwartaal is niet verrassend, aangezien de detailhandelsverkopen sterk waren, de werkloosheid laag was en de loongroei sterk was gedurende deze periode. Er wordt niet verwacht dat de tweede correctie van deze gegevens een sterke reactie op de markt zal veroorzaken. De in november uitgebrachte ISM-manufacturing PMI op vrijdag wordt verwacht licht te stijgen, maar zal nog steeds binnen het krimpbereik blijven.</p>
<p>Het echte hoogtepunt is een reeks gegevens op donderdag, waaronder de PCE-kernprijsindex en persoonlijke inkomsten en uitgaven. De PCE-gegevens zijn een favoriete inflatie-indicator van de Federal Reserve, die zal helpen de omvang van het anti-inflatieproces te verklaren en de prijsstelling van renteverlagingen in de markt te valideren. Het totale jaar-op-jaar groeipercentage van PCE in de Verenigde Staten in oktober zal naar verwachting vertragen van 3,4% naar 3,1%, terwijl de kern-PCE naar verwachting zal vertragen van 3,7% naar 3,5%.</p>
<p>Van maand op maand wordt verwacht dat de algehele en kern-PCE-groeicijfers respectievelijk 0,1% en 0,2% zullen zijn. Elke verdere afkoeling van de prijsdruk zal het steeds moeilijker maken voor de Federal Reserve om de marktverwachtingen voor renteverlagingen te beheersen. Bovendien wordt verwacht dat het persoonlijk inkomen en de uitgaven in oktober zullen vertragen, met een maand-op-maand groei van slechts 0,2%, wat erop wijst dat consumenten hun gordel aantrekken aan het begin van het nieuwe kwartaal na een zware uitgavenperiode in de zomer.</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 beleggingsaanbeveling.<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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>