RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gU3BvdCBFVEYncyBrdW5uZW4gaW4gamFudWFyaSB2b2xnZW5kIGphYXIgd29yZGVuIGdvZWRnZWtldXJkOyBJbmRpYSBiZXZpbmR0IHppY2ggaW4gZWVuIGxlaWRlbmRlIHBvc2l0aWUgaW4gQ3J5cHRvOyBDWUJFUiwgQVBFIGVuIFJPU0UgenVsbGVuIGRlemUgd2VlayBncm90ZSBob2V2ZWV

2023-11-13, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/16998562121_13.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Matrixports20Zes20Voorspellingen20over20de20Crypto20Markt20Vier20Tokens20zullen20Deze20Week20in20Grote20Hoeveelheid20Ontgrendeld20Worden222601"><a name="Crypto Dagelijkse Samenvatting: Matrixport’s Zes Voorspellingen over de Crypto Markt, Vier Tokens zullen Deze Week in Grote Hoeveelheid Ontgrendeld Worden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Matrixport’s Zes Voorspellingen over de Crypto Markt, Vier Tokens zullen Deze Week in Grote Hoeveelheid Ontgrendeld Worden</h2><p>Matrixport-analist Markus Thielen heeft zes voorspellingen gedaan voor de cryptomarkt in de eerste helft van 2024, namelijk de goedkeuring van Bitcoin-spot-ETF’s door de Amerikaanse Securities and Exchange Commission (SEC) in januari, de mogelijkheid van een notering van Circle in april, FTX 2.0 die zijn activiteiten start in mei of juni en zijn positie binnen 12 maanden herstelt als een van de top drie beurzen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> EIP-4844 upgrade plan wordt uitgevoerd in het eerste kwartaal van 2024, en de eerste renteverlaging door de Federal Reserve in juni.</p>
<p>Andrei Grachev, mede-oprichter van DWF-Labs, verklaarde in een bericht dat de CMC-index binnen 30 dagen van angst naar bijna extreme hebzucht ging. De markt voelt veel goede verwachtingen en bijna geen bedreiging. Maar wees voorzichtig bij het gebruik van meerdere hefboomwerkingen, de markt is nog steeds onstabiel, maar als u aan het bouwen en financieren bent, is dit de beste tijd.</p>
<p>Grachev voegde ook toe dat de handelsvolume is verdubbeld, de handelsactiviteit zich herstelt en de liquiditeit toeneemt. Belangrijk is dat dit wordt gedreven door particuliere beleggers, niet door algoritmische handelaren, aangezien we zien dat verschillende Altcoins deze week zijn gestegen. Dit zijn allemaal tekenen van herstel. Hoewel het nog niet het Altcoin-seizoen is, speculeren mensen al.</p>
<p>Volgens <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> News gaf Michael Saylor, mede-oprichter van MicroStrategy, onlangs een uitgebreid perspectief op de toekomstige ontwikkelingstraject van BTC tijdens de Australian Cryptocurrency Conference van 2023. Hij sprak over de BTC-halvering in 2024 en voorspelde dat volgend jaar cruciaal zal zijn voor BTC, omdat het tegen het einde van volgend jaar een ‘mainstream asset tijdens de adolescentie’ zal worden.</p>
<p>Kijkend naar 2024-2028 voorspelt Saylor dat BTC een fase van hoge groei zal ingaan en dat grote technologie-industrieën en banken over de hele wereld BTC breed zullen aannemen en integreren in hun respectieve producten en diensten.</p>
<p>Bovendien wees hij erop dat grote financiële instellingen zoals JPMorgan Chase, Morgan Stanley, Goldman Sachs, Bank of America en Deutsche Bank mogelijk betrokken zijn bij activiteiten zoals het verstrekken van leningen, het verstrekken van onderpand, het aanpassen en kopen en verkopen van Bitcoin.</p>
<p>Vanuit een langetermijnperspectief van ongeveer 25 jaar voorspelt Saylor dat BTC alle hoogwaardige activa zal domineren en benadrukt zijn potentieel om de groei van de S&amp;P 500-index en gediversifieerde beleggingsportefeuilles te overtreffen.</p>
<p>Volgens nieuws. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, Amerikaans senator Cynthia Lummis verdedigde cryptocurrency en verzette zich tegen de claim dat deze activaklasse veelvuldig wordt gebruikt voor illegale financiering. De senator benadrukte dat ‘cryptocurrencies geen probleem zijn, er zijn slechte actoren in elke industrie.’ Cynthia Lummis wees erop dat cryptocurrencies minder dan 1% vertegenwoordigen van alle illegale financiële activiteiten. Daarnaast drong ze er ook bij het Congres op aan om een regelgevend kader vast te stellen dat cryptocurrencybedrijven in staat stelt om in de Verenigde Staten te opereren, in plaats van ze naar ‘ongereguleerde buitenlandse markten’ te duwen.</p>
<p>Volgens het rapport van de Global Cryptocurrency Adoption Index 2023, uitgebracht door het blockchain-analyseplatform Chainalysis, staat India op de eerste plaats wat betreft cryptocurrency-adoptie. Deze index komt voor in Chainalysis’s jaarlijkse ‘Cryptocurrency Geography’ rapport, waarin specifiek de adoptie van cryptocurrencies door de algemene bevolking wordt geëvalueerd, in plaats van alleen te focussen op transactievolume. India staat hoger in de index dan andere landen met hogere niveaus van cryptocurrency-handel en mijnactiviteiten.</p>
<p>Bovendien stond India op basis van de oorspronkelijk geschatte waarde van de ontvangen cryptocurrency tussen juli 2022 en juni 2023 op de tweede plaats onder de best gerangschikte landen. Volgens het Chainalysis-rapport ontving India in het afgelopen jaar ongeveer $250 miljard aan cryptocurrency-waarde, op de tweede plaats na de Verenigde Staten, waarbij de Verenigde Staten ongeveer $1 biljoen aan cryptocurrency-waarde ontvingen gedurende dezelfde periode.</p>
<p>India staat op de eerste plaats in de uitgebreide indexranglijsten, gecentraliseerde servicewaarderingsranglijsten, winkelcentrale servicewaarderingsranglijsten en DeFi-waarderingsranglijsten, maar op de vijfde plaats in de ranglijsten van het handelsvolume van P2P-uitwisseling. Nigeria, Vietnam, de Verenigde Staten, Oekraïne, de Filipijnen en Indonesië volgen India op de voet.</p>
<p>Deze week ontvangen CYBER, APE en ROSE een eenmalige grote ontgrendeling van tokens, met een totale releasewaarde van meer dan $ 48 miljoen. Onder hen:</p>
<p>Op 15 november om 2:14 uur (UTC) zal CyberConnect 1,26 miljoen CYBERs (ongeveer $8,34 miljoen) ontgrendelen, wat overeenkomt met 11,43% van de omloopvoorraad;</p>
<p>Op 16 november om 8:00 (UTC) <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> zal 2,6 miljoen FLOW’s ontgrendelen (ongeveer $1,81 miljoen), wat overeenkomt met 0,25% van de circulerende voorraad;</p>
<p>Op 17 november om 8:00 (UTC) <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zal 15,6 miljoen APE’s ontgrendelen (ongeveer $23,25 miljoen), wat overeenkomt met 4,23% van de circulerende voorraad;</p>
<p>Om 12:00 (UTC) op 19 november, <a href="/price/oasis-network-rose" rel="nofollow noopener noreferrer" target="_blank">Oasis Network</a> zal 196 miljoen ROSE’s ontgrendelen (ongeveer $14,5 miljoen), wat overeenkomt met 3,9% van het circulerende aanbod.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag523671"><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-BTC943436"><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/169985642314501699856352_.pic.jpg" alt=""><br>Vorige week sloot BTC op het niveau van $37.000 USD. Deze week opende het met een hoge en vlakke prestatie, zonder significante trend te laten zien. Verwacht wordt dat het geleidelijk zal blijven dalen naar de steun van $36.000 USD en weerstand zal ondervinden op $37.755 USD. De wekelijkse trend kan dalen tot een minimum van $32.850 USD.</p>
<h3 id="h3-ETH780215"><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/169985644714511699856374_.pic_hd.jpg" alt=""><br>De daggrafiek probeert de weerstand van $2.135 USD te doorbreken en bereikt daarmee een relatief hoog punt in anderhalf jaar. Het korte termijn advies is om stand te houden op $2.037 USD. Bij succes wordt verwacht dat de uitdaging is om de $2.135 USD te doorbreken en $2.381 USD te bereiken. Ook is er een suggestie om de trend te volgen met een stand op $2.045 USD.</p>
<h3 id="h3-FTT463527"><a name="FTT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTT</h3><p><img src="https://gimg2.gateimg.com/image/article/169985647214521699856394_.pic.jpg" alt=""><br>De algehele trend van $1.3965 USD tot $1.56 USD is gestegen naar een hoogtepunt van $5 USD. Korte termijn ondersteuning bevindt zich op $3.21 USD en weerstand moet consequent doorbreken naar $4.92 USD om te kunnen mikken op $6.49 USD en $11.04 USD.</p>
<h2 id="h2-Macro20Moodys20beoordeelt20de20Verenigde20Staten20als20negatief20focus20op20CPIgegevens20deze20week293521"><a name="Macro: Moody’s beoordeelt de Verenigde Staten als negatief, focus op CPI-gegevens deze week" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Moody’s beoordeelt de Verenigde Staten als negatief, focus op CPI-gegevens deze week</h2><p>Vorige week heeft de toespraak van de voorzitter van de Federal Reserve, Powell, het vorige ‘duifachtige prijsstelling’ in de markt krachtig omvergeworpen en de markt opnieuw in ‘havikachtige chaos’ gestort. De sterke Amerikaanse dollar boekte zijn beste wekelijkse prestatie sinds augustus, goud keerde terug naar het niveau van bijna $1.930 en de veiling van Amerikaanse obligaties met een looptijd van 30 jaar luidde een liquiditeitsalarm in.</p>
<p>Moody’s, het enige van de drie belangrijkste ratingbureaus ter wereld dat de hoogste rating van de Amerikaanse overheid handhaaft, heeft ook aangekondigd na sluiting van de Amerikaanse beurs afgelopen vrijdag dat het zijn hoogste investeringswaardering Aaa handhaaft, maar zijn beoordelingsperspectief aanpast van stabiel naar negatief. Moody’s belangrijkste overweging bij het nemen van deze beslissing is de aanhoudend hoge rente in de Verenigde Staten in combinatie met een groot begrotingstekort, samen met de huidige stand van onderhandelingen in het Congres.</p>
<p>In de nieuwe week zullen CPI-gegevens en ‘paniekgegevens’ hand in hand komen, en het Palestijns-Israëlische conflict blijft de zenuwen van handelaren verstoren. Ook de ‘shutdown’ van de Amerikaanse overheid nadert.</p>
<p>De Federal Reserve handhaafde zijn referentie rente op een hoogtepunt van 22 jaar na zijn vergadering in november.</p>
<p>Door het tegenvallende werkgelegenheidsrapport in de Verenigde Staten heeft de Amerikaanse dollar een flinke klap gekregen. Vorige week wezen verschillende functionarissen van de Federal Reserve erop dat de uitstekende prestaties van de Amerikaanse economie de deur hebben geopend voor verdere renteverhogingen en dat er een zwak herstel van de Amerikaanse dollar is geweest. Afgelopen donderdag nog verklaarde Federal Reserve-voorzitter Powell dat functionarissen “niet geloven” dat de rentetarieven hoog genoeg zijn om het einde van de strijd tegen de inflatie aan te geven.</p>
<p>Powell verklaarde in een toespraak bij het Internationaal Monetair Fonds (IMF) op donderdag dat er mogelijk meer maatregelen nodig zullen zijn om de inflatie te verlagen tot 2%. De markt interpreteert de opmerkingen van Powell als havikachtig en verandert daarmee de voorzichtige toon die hij vorige week tijdens de beleidsvergadering uitte.</p>
<p>Niettemin geloven investeerders nog steeds grotendeels niet dat de Federal Reserve de rente opnieuw zal verhogen. Volgens de federal fund futures geloven zij dat er slechts een kans van 20% is op een laatste renteverhoging van 25 basispunten tegen januari volgend jaar, en zij verwachten een renteverlaging van ongeveer 80 basispunten tegen het einde van volgend jaar.</p>
<p>Misschien is het omdat er nog steeds veel ‘duif-stand leden’ binnen de Federal Reserve zijn, of misschien verwachten marktdeelnemers dat de inflatie opnieuw zal dalen, vooral na de daling van de olieprijzen in oktober, wanneer de economie zal blijven verzwakken.</p>
<p>In feite schat het GDPNow-model van de Atlanta Fed dat de geannualiseerde groeisnelheid van de Verenigde Staten in het vierde kwartaal 2,1% was, wat normaal lijkt in een omgeving van hoge rentetarieven en een versnelling van de Amerikaanse economie tot 4,9% in het derde kwartaal.</p>
<p>Gezien dit alles kan de focus van deze week verschuiven naar de in oktober gepubliceerde Amerikaanse CPI-gegevens op dinsdag, die een sleutelrapport kunnen zijn bij het bepalen of de Federal Reserve in december actie onderneemt.</p>
<p>Verwacht wordt dat het jaar-op-jaar groeipercentage van de algehele CPI zal dalen van 3,7% naar 3,3%, en het jaar-op-jaar groeipercentage van de kern-CPI zal dalen van 4,1% naar 4,0%. Bovendien, gezien het feit dat de PMI in oktober een afname van de prijsdruk liet zien, kan het inflatierisico neigen te dalen, en aangezien de jaar-op-jaar verandering in de olieprijzen opnieuw negatief wordt, kan de algehele inflatie blijven verzwakken voor het einde van het jaar.</p>
<p>Hoewel de kern-CPI nog steeds in een stabiel tempo vertraagt, is de algehele inflatie in de Verenigde Staten de afgelopen drie maanden licht gestegen. In september vertraagde de kern-CPI in de Verenigde Staten van 4,3% naar 4,1%, voornamelijk als gevolg van de lichte stijging van de huur- en brandstofprijzen. Dit heeft inderdaad zorgen gewekt dat de Federal Reserve naar verwachting de rente opnieuw zal verhogen tussen nu en het einde van het jaar.</p>
<p>Voor de Federal Reserve-functionarissen die deze week verschenen, is het vanzelfsprekend dat Chicago Fed-voorzitter Goolsby een fervent “duif” is, terwijl New York Fed-voorzitter Williams een “standvastige bondgenoot” van Powell is en naar verwachting enkele van Powell’s standpunten zal herhalen die hij op donderdag heeft geuit. Boston Fed-voorzitter Collins en San Francisco Fed-voorzitter Daley worden verwacht de verwachtingen van de Fed voor “hoger en langer” voort te zetten.</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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>