RGFpbHkgTmV3cyB8IFNwb3QgRVRGIEZha2UgTmV3cyB2ZXJob29ndCBYUlAgdG90IGVlbiBzdGlqZ2luZyB2YW4gbWVlciBkYW4gMTAlLCA5JSB2YW4gZGUgRnJhbnNlIGludmVzdGVlcmRlcnMgaGVlZnQgZ2XDr252ZXN0ZWVyZCBpbiBjcnlwdG8tYWN0aXZhLCBOYW5zZW4gdm9vcnNwZWx0IDExIGthdGFseXNhdG9yZW4gdm9vciBlZW4

2023-11-14, 03:50

<p><img src="https://gimg2.gateimg.com/image/article/16999404081_14.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20APEC20bespreekt20digitale20activa20spot20ETF20nepnieuws20stimuleert20XRP20om20met20meer20dan201020te20stijgen312933"><a name="Crypto Dagelijkse Samenvatting: APEC bespreekt digitale activa, spot ETF nepnieuws stimuleert XRP om met meer dan 10% te stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: APEC bespreekt digitale activa, spot ETF nepnieuws stimuleert <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> om met meer dan 10% te stijgen</h2><p>De weeklange top van de Asia-Pacific Economic Cooperation (APEC) werd geopend in San Francisco op 11 november.</p>
<p>De Amerikaanse minister van Financiën Janet Yellen verklaarde in haar openingsrede op de vergadering van 13 november dat ze zou spreken over “langetermijn-prioriteitsontwikkelingsgebieden” met de nadruk op duurzaamheid. Ze zullen ook twee vergaderingen houden om het aanbodzijde-economie en digitale activa te bespreken.</p>
<p>Yellen noemde specifiek niet-geborgde cryptomiddelen, stablecoin en door de centrale bank uitgegeven digitale valuta. Het delen van inzichten en samenwerken met de particuliere sector stelt ons in staat een dieper inzicht te krijgen in de tools die beleidsmakers kunnen gebruiken om verantwoord digitale activa te ontwikkelen en te gebruiken,” zei Yellen.</p>
<p>Volgens Spot On Chain monitoring heeft FTX de afgelopen 5 uur nog eens drie activa ter waarde van $24 miljoen gestort bij Kraken en OKX, waaronder 250.000 SOL’s ($13,5 miljoen), 8,27 miljoen MATIC’s ($7,41 miljoen) en 1500 ETH’s ($3,1 miljoen).</p>
<p>Over het algemeen hebben FTX en Alameda tot 14 november 42 activa ter waarde van $438 miljoen naar de beurs overgebracht. Momenteel heeft FTX nog slechts 3408 SOL’s ($179.000) aan liquiditeit over. Volgens de gegevens van CoinGecko houden ze echter nog steeds 42,2 miljoen SOL’s ($2,19 miljard) in een vergrendelde staat. Deze SOL’s worden pas volgend jaar ontgrendeld en blijven grotendeels bevroren tot 2027 of 2028.</p>
<p>Volgens CoinDesk heeft BlackRock gereageerd op eerder nieuws over de aanvraag voor registratie van iShares. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Vertrouwen in Delaware, een woordvoerder van BlackRock verklaarde dat de regelgevende documenten die online circuleren nep waren en dat BlackRock geen plannen had om XRP-spot ETF’s te lanceren. De prijs van de Zwitserse valuta steeg met meer dan 10% na het valse nieuws, maar is nu weer gedaald tot ongeveer $0.65.</p>
<p>BlackRock heeft eerder ingediend <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Aanvragen voor spot ETF’s bij de Amerikaanse Securities and Exchange Commission (SEC). Voordat BlackRock zijn aanvraag bij de SEC indient, registreert het eerst de relevante ETF in Delaware.</p>
<p>Nadat er nepnieuws naar buiten kwam dat BlackRock Ripple (XRP) Trust had geregistreerd op de website van de Delaware bedrijfsregistratie, moest een XRP-futurepositie ter waarde van $6 miljoen worden gesloten.</p>
<p>Een onderzoek uitgevoerd door de Franse Monetaire Autoriteit (AMF) met de ondersteuning van EU-technische ondersteuningstools toont aan dat tegen 2023 9% van de volwassenen in Frankrijk cryptomiddelen bezit. De enquête van de AMF richtte zich op meer dan 1000 nieuwe particuliere beleggers in Frankrijk en de resultaten toonden aan dat 24% van de volwassenen in Frankrijk investeert in verschillende financiële instrumenten. Een groot deel hiervan wordt geïnvesteerd in cryptocurrencies.</p>
<p>Hoewel traditionele investeringen nog steeds de overhand hebben in beleggingsportefeuilles, benadrukt de voorkeur voor crypto-activa, met name onder jongeren, de generatiewisseling in beleggingsvoorkeuren en de geleidelijke acceptatie van digitale financiële oplossingen in het land.</p>
<p>De AMF-enquête geeft een gedetailleerde uitleg: “nieuwe beleggers investeren minder vaak op de aandelenmarkt dan traditionele beleggers.” “Veel mensen zijn geïnteresseerd in crypto-activa: 54% van hen bezit crypto-activa (63% van de nieuwe investeerders in de leeftijd van 25-34 bezit deze activa), terwijl het percentage traditionele beleggers 25% is.”</p>
<p>Onlangs heeft Alex Svanevik, oprichter van het blockchain data-analyseplatform Nansen, vanwege de uitstekende prestaties van de cryptomarkt een Twitter-analyse uitgebracht van 11 katalysatoren die een nieuwe bullmarkt stimuleren, met name:</p>
<ol>
<li><p>De ergste tijd is voorbij, de verkoper die gedwongen werd te verkopen is verdwenen en de oplichter zit in de gevangenis;</p>
</li><li><p>BTC spot ETF’s kunnen binnen enkele maanden worden goedgekeurd en instellingen kunnen de markt betreden;</p>
</li><li><p>Financiële technologiebedrijven betreden de blockchain en de uitgifte van stablecoins door PayPal is een ‘kanarie’ in de kolenmijnen (een bijzonder gevoelige indicator voor economische schommelingen, die een signaal vertegenwoordigt). Andere financiële technologiebedrijven zullen ook vergelijkbare maatregelen nemen en sommige banken zullen stablecoins lanceren in 2024;</p>
</li><li><p>We hebben nieuwe producten gezien die echt de moeite waard zijn om aan deel te nemen aan socializen en gokken;</p>
</li><li><p>De handelsvolume van NFT heeft een maand geleden een dieptepunt bereikt en vertoont sindsdien een opwaartse trend;</p>
</li><li><p>De Web3-games die in de afgelopen twee jaar zijn ontwikkeld, zijn begonnen met de lancering. Ik heb er een paar gespeeld, maar we hebben slechts één verbluffend spel nodig;</p>
</li><li><p>Technologische ontwikkelingen hebben het voor gewone mensen makkelijker gemaakt om mee te doen, met lagere gasvergoedingen op L2 en andere ketens. Account abstractie betekent dat gebruikers de cryptowereld kunnen betreden zonder de noodzaak van mnemonics;</p>
</li><li><p>Het DeFi-veld wordt nu aangedreven door liquid staking tokens (LST’s) en real-world assets (RWA’s), en opbrengsten hoeven niet te vertrouwen op Ponzi-schema’s;</p>
</li><li><p>De niet-gerealiseerde winst van MicroStrategy’s <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> overtreft $1 miljard, waardoor het bedrijf FOMO kan bereiken;</p>
</li><li><p>Het monetair beleid van de Federal Reserve is zelfs niet gewijzigd (er kunnen in de toekomst renteverlagingen zijn);</p>
</li><li><p>Bitcoin zal volgend jaar een halvering ondergaan.</p>
</li></ol>
<p>Bovendien is Alex Svanevik van mening dat DeFi 1.0 profiteert van liquiditeitsmining en Ponzi-schema’s, wat niet duurzaam is. DeFi 2.0 profiteert van LST en RWA, wat duurzaam is. Volgens hem is DeFi 2.0 nu begonnen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag137571"><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-BTC986582"><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/1699940472btc.png" alt=""><br>Afgelopen week sloot rond de $37.000, en deze week opende met een hoog maar relatief vlak resultaat. Er zijn geen significante trends en het wordt verwacht dat het gestaag doorgaat, terugtrekkend naar het niveau van $36.000. De wekelijkse trend kan dalen tot een minimum van $32.850, wat wijst op een bullish retracement.</p>
<h3 id="h3-ETH910345"><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/1699940495eth.png" alt=""><br>De daggrafiek probeert de weerstand van $2.135 te doorbreken en bereikt een relatieve hoogte die in anderhalf jaar niet is gezien. Korte termijn steun op $2.037 wordt vastgehouden, en als het succesvol $2.135 doorbreekt, kan het $2.381 bereiken. Dit kan leiden tot een rally in altcoins en het wordt aanbevolen om te kijken naar steun op $2.030.</p>
<h3 id="h3-VERBINDEN910117"><a name="VERBINDEN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VERBINDEN</h3><p><img src="https://gimg2.gateimg.com/image/article/1699940525link.png" alt=""><br>De korte termijn strategie suggereert vasthouden en overwegen van de $14.40 ondersteuning. Langetermijndoelen zijn historische hoogtepunten op $54.31 en mijlpalen op $79.80, $107.5 en $125.89. Het conservatieve advies is om lang posities vast te houden.</p>
<h2 id="h2-Macro20Inflatieverwachtingen20zijn20afgenomen20Goldman20Sachs20voorspelt20nog20eens201220renteverhogingen20volgend20jaar764136"><a name="Macro: Inflatieverwachtingen zijn afgenomen, Goldman Sachs voorspelt nog eens 1-2 renteverhogingen volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Inflatieverwachtingen zijn afgenomen, Goldman Sachs voorspelt nog eens 1-2 renteverhogingen volgend jaar</h2><p>Op maandag daalde de Amerikaanse dollarkoers nadat deze het niveau van 106 had bereikt, en sloot uiteindelijk met een daling van 0,132% op 105,68. Het rendement op Amerikaanse staatsobligaties is gedaald, waarbij het rendement op 10-jarige obligaties sloot op 4,64%; Het rendement op 2-jarige Amerikaanse staatsobligaties, dat gevoeliger is voor het rentebeleid van de Federal Reserve, sloot op 5,033%. De drie belangrijkste Amerikaanse aandelenindices hebben geschommeld. De Dow steeg met 0,1%, de Nasdaq daalde met 0,22% en de S&amp;P 500 daalde met 0,08%.</p>
<p>Spotgoud daalde eerst en steeg vervolgens, waarbij de Amerikaanse markt bleef stijgen, bijna de $1950-niveau bereikte en uiteindelijk 0,3% hoger sloot op $1946,26 per ounce; Spotzilver herstelde zich nadat het onder de 22-grens was gezakt tijdens de intradayhandel, en bijna alle intradayverliezen uitwiste, en uiteindelijk sloot op $22,31 per ounce.</p>
<p>Internationale olieprijzen zijn gestegen naar een nieuw hoogtepunt sinds 7 november, omdat het maandelijkse rapport van OPEC de markt van zorgen over de vraag verlicht, terwijl het Amerikaanse onderzoek naar vermoede schendingen van Russische oliesancties door scheepvaartmaatschappijen zorgen heeft opgewekt over mogelijke aanvoeronderbrekingen. WTI-ruwe olie sloot 1,51% hoger op $78,47 per vat; Brent-ruwe olie sloot 1,25% hoger op $82,63 per vat.</p>
<p>Volgens een enquête van de New York Federal Reserve zal de inflatieverwachting over één jaar dalen van 3,7% in september naar 3,6%. De inflatieverwachting over drie jaar zal 3% bedragen, hetzelfde als in september. De inflatieverwachting over vijf jaar zal dalen van 2,8% in september naar 2,7%.</p>
<p>Federal Reserve-voorzitter Powell verklaarde tijdens een persconferentie na de vergadering van het Federal Open Market Committee (FOMC) dat de inflatieverwachtingen nog steeds ‘goed verankerd’ zijn en voegde eraan toe dat ‘het duidelijk is dat de inflatieverwachtingen in een goede staat verkeren’ en ‘er zijn geen echte zwakke plekken’.</p>
<p>In zijn opmerkingen van afgelopen vrijdag erkende Powell dat “inflatie ons enkele illusies heeft gebracht” en herhaalde hij dat, indien nodig, de Federal Reserve de rente opnieuw zal verhogen om de inflatie onder controle te houden.</p>
<p>Jeffrey Roach, hoofdeconoom bij LPL Finance, verklaarde dat “beleggers aandacht moeten besteden aan de meer bemoedigende enquêtes die worden vrijgegeven door de New York Fed.” Hij wees erop dat de steekproefbasis van de enquête van de New York Fed groter en uitgebreider is in het weerspiegelen van het consumentengedrag dan de enquête van de University of Michigan.</p>
<p>Over het algemeen verwachten economen nog steeds dat de inflatie langzaam zal afnemen. De Philadelphia Federal Reserve verklaarde op maandag in haar laatste driemaandelijkse professionele prognose-enquête dat economen verwachten dat de inflatie, gemeten aan de hand van de Persoonlijke Consumptieprijsindex (PCE), de voorkeursinflatie-indicator van de Fed, tegen 2024 nog steeds boven de 2% zal liggen. Tegen het laatste kwartaal van 2024 zal het geannualiseerde inflatiepercentage 2,3% bereiken.</p>
<p>Op dinsdag wordt er een andere belangrijke inflatietestdata vrijgegeven. De kern-CPI, exclusief voedsel en energie, wordt verwacht in oktober met 4,1% te stijgen, wat overeenkomt met de gegevens van september, terwijl de algemene inflatie naar verwachting zal afnemen.</p>
<p>Het onderzoeksrapport van Goldman Sachs wijst erop dat de moeilijke fase van de inflatiebestrijding in de Verenigde Staten nu voorbij lijkt te zijn. Zodra de kern-PCE in de Verenigde Staten onder de 2,5% zakt, wordt verwacht dat de Federal Reserve de rente vanaf het vierde kwartaal van 2024 tot het tweede kwartaal van 2026 met 25 basispunten per kwartaal zal verlagen.</p>
<p>Er zijn nog steeds twee belangrijke risico’s: stijgende olieprijzen en de mogelijkheid dat er iets breekt in de nieuwe renteomgeving. Het risico is reëel maar beheersbaar, mede omdat de Federal Reserve volgend jaar vrij is om de rente te verlagen en voldoende ruimte heeft.</p>
<p>Goldman Sachs CEO Solomon wees erop dat het risico op een economische recessie in de Verenigde Staten aanzienlijk is afgenomen in vergelijking met 12 maanden geleden en dat er een grote kans is op een zachte landing in de economie. Echter, de snelle groei van de Aziatische economie zal op de lange termijn meer internationale fondsen aantrekken om te investeren in de regionale kapitaalmarkten.</p>
<p>Solomon gelooft dat hoewel de inflatie in de Verenigde Staten enigszins is afgenomen, het nog ver verwijderd is van het beleidsdoel van de Federal Reserve van 2%. Hij voorspelt persoonlijk dat inflatiekwesties de lokale economie gedurende een bepaalde periode zullen beïnvloeden en sluit niet uit dat de Federal Reserve de rente opnieuw zal verhogen wanneer de inflatie weer stijgt. Er is echter weinig kans dat de rente dit jaar opnieuw wordt verhoogd en er kunnen één of twee renteverhogingen volgend jaar zijn. De Amerikaanse economie staat voor veel onzekere factoren en over het algemeen is de kans op een zachte landing relatief hoog.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor 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>