RGFnZWxpamtzIG5pZXV3cyB8IERlIFZTIHphbCB6aWpuIGVlcnN0ZSB2ZXJzaWUgdmFuIGhldCBjcnlwdG8tYWNjb3VudGluZ3N5c3RlZW0gaW50cm9kdWNlcmVuLCBKUE1vcmdhbiBDaGFzZSB2b29yc3BlbHQgZGF0IEVUSCBoZXQga29tZW5kZSBqYWFyIGJldGVyIHphbCBwcmVzdGVyZW4gZGFuIEJUQw==

2023-12-14, 04:01

<p><img src="https://gimg2.gateimg.com/image/article/17025350901_9.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20Verenigde20Staten20zal20zijn20eerste20versie20van20cryptoaccountingsysteem20introduceren20JPMorgan20Chase20voorspelt20dat20Ethereum20volgend20jaar20beter20zal20presteren20dan20Bitcoin795770"><a name="Crypto Dagelijkse Samenvatting: De Verenigde Staten zal zijn eerste versie van crypto-accountingsysteem introduceren, JPMorgan Chase voorspelt dat Ethereum volgend jaar beter zal presteren dan Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De Verenigde Staten zal zijn eerste versie van crypto-accountingsysteem introduceren, JPMorgan Chase voorspelt dat <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> volgend jaar beter zal presteren dan Bitcoin</h2><p>Op woensdag heeft de Financial Accounting Standards Board (FASB) de eerste reeks regels voor crypto-accounting vrijgegeven, waarbij bedrijven worden verplicht om hun bezit van cryptocurrencies tegen eerlijke waarde te meten. De nieuwe voorschriften zullen in 2025 van kracht worden, maar staan vroegtijdige invoering toe.</p>
<p>Deze regelwijziging betekent dat bedrijven zoals MicroStrategy, Tesla en Block in staat zullen zijn om de hoogte- en dieptepunten van hun cryptobezit vast te leggen. Volgens de nieuwe regelgeving kunnen bedrijven die cryptocurrencies bezitten zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> of <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zal deze tokens moeten opnemen tegen de reële waarde, die de meest recente marktwaarde is. Veranderingen in de reële waarde zullen rechtstreeks worden erkend in het nettoresultaat.</p>
<p>Volgens de nieuwe regels moeten bedrijven hun crypto-activa afzonderlijk op hun balans opnemen als een post. Ze moeten ook een aanzienlijke hoeveelheid crypto-aandelen en eventuele beperkingen op deze aandelen bekendmaken in de voetnoten van elke rapportageperiode. Elk jaar moeten ze de opening- en eindbalansen van crypto-activa per categorie verzoenen of wijzigingen bekendmaken.</p>
<p>Op het gebied van regelgeving verklaarde Rostin Behnam, voorzitter van de Commodity Futures Trading Commission (CFTC) in de Verenigde Staten, dat de meeste crypto-activa onder de huidige wetgeving als grondstoffen worden beschouwd, en hij erkent dat regelgevende instanties betrokken zijn bij een “territoriumoorlog” over wie de bevoegdheid heeft om de cryptobranche te reguleren.</p>
<p>Bij het bespreken van de regelgevingscomplexiteit waarmee de crypto-industrie wordt geconfronteerd, benadrukte Behnam de noodzaak van dringende wetgevende maatregelen en verklaarde dat ‘leden van het Congres hard werken om de situatie te begrijpen’. Behnam wees erop dat een van de uitdagingen bij het reguleren van digitale activa de voortdurende ‘machtsstrijd’ is tussen verschillende regelgevende instanties in het land, met name het geschil tussen de Amerikaanse Securities and Exchange Commission (SEC) en de CFTC over wie de industrie zal reguleren. Dit conflict is een belangrijke hindernis geworden bij het vaststellen van duidelijke regelgevende richtlijnen voor digitale activa en de bredere crypto-industrie.</p>
<p>Terwijl de markt zich herstelt, zijn ook bekende investeringsbanken naar voren gekomen om verkeer te genereren. Analisten van JPMorgan zeggen dat de algehele crypto-markt ‘voorzichtig’ blijft in het komende jaar, maar dat de prestaties van Ethereum in 2024 die van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en andere cryptocurrencies kunnen overtreffen.</p>
<p>Analisten van JPMorgan onder leiding van Nikolaos Panigrtzoglou schreven in een rapport op woensdag: “We geloven dat Ethereum volgend jaar zijn positie zal herstellen en marktaandeel zal terugwinnen in het crypto-ecosysteem.” De belangrijkste katalysator is de EIP-4844-upgrade, die naar verwachting in de eerste helft van 2024 zal plaatsvinden. Deze upgrade kan een grotere stap zetten naar het verbeteren van de netwerkactiviteiten van Ethereum, waardoor Ethereum goed kan presteren.</p>
<p>JPMorgan-analisten benadrukten dat deze upgrade met name gunstig is voor L2-netwerken zoals Arbitrum en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, omdat het extra tijdelijke gegevensruimte biedt om de netwerkdoorvoer te verhogen en transactiekosten te verlagen voor Ethereum L2-netwerken. Analisten van JPMorgan verklaarden ook dat factoren die volgend jaar gunstig worden geacht voor Bitcoin, waaronder de mogelijke goedkeuring van spot-ETF’s en de aanstaande halvering, in de prijs zijn verwerkt.</p>
<p>De analist concludeerde: “gezien de huidige verhouding van de Bitcoinprijzen tot productiekosten ongeveer twee keer is, betekent dit dat de Bitcoin-halvering in 2024 grotendeels in de prijs is weerspiegeld.”</p>
<p>Matthew McDermott, Global Head of Digital Assets bij Goldman Sachs, zei dat er verwacht wordt dat de handelsvolumes van op blockchain gebaseerde activa in de komende één of twee jaar ‘aanzienlijk zullen toenemen’. McDermott verklaarde dat Goldman Sachs, gezien de verwachting dat Amerikaanse effectenregulatoren binnenkort goedkeuring zullen verlenen voor aanvragen voor spot Bitcoin ETF’s (exchange traded funds), ook een toenemende interesse heeft gezien in de handel in crypto-derivaten onder klanten.</p>
<p>Bitcoin steeg meer dan 50% dit kwartaal, maar McDermott verklaarde dat hij zich nog steeds richt op het ontwikkelen van digitale activa buiten cryptocurrency, waaronder het uitgeven van op blockchain gebaseerde tokens die traditionele activa zoals obligaties vertegenwoordigen. Hij verklaarde dat er een ‘enorme vraag’ is naar digitale activa en dat er in de afgelopen 12 maanden ‘aanzienlijke groei’ is geweest; Het gebruik van blockchain kan operationele en afwikkelingsefficiëntie verbeteren, evenals ‘financiële markten ont-risken’; Als effectenhandel via blockchain wordt uitgevoerd, kunnen onderpand en liquiditeit sneller en nauwkeuriger tussen partijen worden verzonden.</p>
<h2 id="h2-Belangrijkste20token20trends20van20vandaag876667"><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-BTC804981"><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/1702535131BTC.png" alt=""><br>Na de algemene stijging van de markt gisteren vroeg, is de grafiek van vier uur teruggekeerd boven de centrale as van de opwaartse trend. Op korte termijn wordt verwacht dat het de bullish trend zal voortzetten met snelle rebounds. Wekelijkse grafiekweerstanden bevinden zich op $45.345 en $47.990. Voor langetermijnstrategieën wordt voorgesteld om te wachten op een tweede pullback voor een conservatieve aanpak, met langetermijnondersteuning op $30.888.</p>
<h3 id="h3-ETH105544"><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/1702535157ETH.png" alt=""><br>Vorige week werd het prijsdoel van $2.381 voor ETH bereikt, en de dagelijkse grafiek suggereert een mogelijke symmetrische driehoek op hoog niveau. Voorzichtigheid is geboden voor een aanzienlijke terugval, terwijl de langetermijnaanbeveling is om de opwaartse trend te handhaven. Het uitbraakdoel ligt op $2.805, met langetermijndoelen op $8.025 en $12.397.</p>
<h3 id="h3-GT504030"><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/1702535350GT.png" alt=""><br>De wekelijkse grafiek toont een gestructureerde markt die het einde van de tweede fase nadert en de derde bullmarktcyclus ingaat. Bij het bespreken van de derde bullmarktcyclus, waar zal het piekdoel van GT zijn?</p>
<p>In de tweede fase heeft GT het eerste doel bereikt op $2.9321 (wat overeenkomt met de 4.236 van de Fibonacci-reeks van de eerste fase) en het tweede doel op $12.8770.</p>
<p>De gele driehoek vertegenwoordigt het bereik van de tweede fase, met mogelijke doelen voor de derde fase op $28.2426, $39.1555 en $44.9951.</p>
<p>Als er een aanhoudende stierenmarkt ontstaat, kunnen prijzen blijven beïnvloeden $110.3832 en $176.8363, afhankelijk van fondsaccumulatie en kansen in de volgende stierenmarktcyclus.</p>
<h2 id="h2-Macro20De20Federal20Reserve20verhoogt20de20duifachtige20positie20de20Fed20Dot20Plot20suggereert20een20renteverlaging20van207520basispunten20volgend20jaar865870"><a name="Macro: De Federal Reserve verhoogt de duifachtige positie, de Fed Dot Plot suggereert een renteverlaging van 75 basispunten volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Federal Reserve verhoogt de duifachtige positie, de Fed Dot Plot suggereert een renteverlaging van 75 basispunten volgend jaar</h2><p>De Federal Reserve heeft aangekondigd dat de rentetarieven ongewijzigd zullen blijven in het bereik van 5,25% tot 5,50%, wat in lijn is met de verwachtingen. Sinds het begin van dit jaar heeft de Federal Reserve de rentetarieven in totaal met 100 basispunten verhoogd en ze sinds september op hun huidige niveau gehandhaafd.</p>
<p>Vanwege de duidelijk dovish houding van de Federal Reserve daalden de Amerikaanse schatkistrendementen over de hele linie, en het rendement op de Amerikaanse 10-jaars schatkist vermeed nipt de 4% grens, en sloot uiteindelijk op 4.024%; Het rendement op de Amerikaanse schatkist van twee jaar, dat gevoeliger is voor de rentetarieven van de Federal Reserve, daalde meer dan 30 basispunten op de dag en sloot op 4.429%. De Amerikaanse dollar index stortte intraday in, daalde onder de 103 grens en sloot uiteindelijk 0.809% lager op 102.98.</p>
<p>De goudprijs steeg scherp nadat het rentebesluit van de Federal Reserve werd aangekondigd en bereikte $2.020 per ounce. Het steeg bijna $50 op de dag en sloot uiteindelijk 2,26% hoger af op $2.024,26 per ounce; De zilverprijs steeg met 4,65% en sloot af op $23,81 per ounce.</p>
<p>Als gevolg van een meer dan verwachte daling van de Amerikaanse voorraden ruwe olie en zorgen over de veiligheid van de olievoorziening in het Midden-Oosten als gevolg van de aanvallen op tankers in de Rode Zee, is de internationale olieprijs iets gestegen na een 5-maands dieptepunt. WTI-ruwe olie sloot 1,7% hoger op $69,95 per vat; Brent-ruwe olie steeg met 1,81% naar $74,81 per vat.</p>
<p>De drie belangrijkste Amerikaanse aandelenindexen sloten gezamenlijk hoger, waarbij de Dow Jones Industrial Average met 1,4% steeg en 37090 punten bereikte, waarmee een nieuw sluitingshoogtepunt werd bereikt. De S&amp;P 500-index sloot 1,37% hoger en de Nasdaq steeg met 1,38%.</p>
<p>Het FOMC-statement van de Federal Reserve toont aan dat de groeisnelheid van de Amerikaanse economie is vertraagd ten opzichte van het sterke groeimomentum in het derde kwartaal. De groei van de werkgelegenheid is vertraagd, maar blijft sterk en de werkloosheid blijft laag. De Amerikaanse inflatie is het afgelopen jaar vertraagd, maar blijft hoog en het FOMC blijft zich sterk inzetten voor het doel om de inflatie te herstellen tot 2%.</p>
<p>De verlaging van het houdingspercentage van Amerikaanse staatsobligaties en MBS blijft ongewijzigd. Het Dot Plot van de Federal Reserve suggereert een renteverlaging van 75 basispunten volgend jaar, met een verwachte federale rentevoet van 4,6% tegen het einde van 2024. Het ‘Dot Plot’ van het comité toont ook vier renteverlagingen in 2025 en drie renteverlagingen in 2026, wat de federale rentevoet aanpast naar het bereik van 2% tot 2,25%. Het verklaarde dat het bereid is om het monetaire beleid verder aan te scherpen onder geschikte omstandigheden.</p>
<p>De Dot Plot toont aan dat acht ambtenaren geloven dat de renteverlaging volgend jaar minder dan 75 basispunten zal zijn, terwijl vijf ambtenaren verwachten dat deze nog groter zal zijn. Dit is de meest chaotische ‘Dot Plot’ die in vele jaren is verschenen.</p>
<p>Nu de Federal Reserve een duifachtige houding aanneemt en de markt meer duifachtig wordt, is er nu een prijsstelling van een renteverlaging van 150 basispunten in 2024 (verkiezingsjaar). Omdat Powell niet heeft gereageerd op de recente renteverlaging, zijn de Amerikaanse schatkistobligaties gestegen, sprongen de Amerikaanse aandelen en verhoogden handelaren hun weddenschappen op de renteverlaging in maart tot bijna zeker niveau (75%).</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat 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>