RGFpbHkgTmV3cyB8IFNwb3QgRVRGIEZha2UgTmV3cyBCb29zdHMgWFJQIHRvIFJpc2UgYnkgT3ZlciAxMCUsIDklIG9mIEZyZW5jaCBJbnZlc3RvcnMgSGF2ZSBJbnZlc3RlZCBpbiBDcnlwdG8gQXNzZXRzLCBOYW5zZW4gUHJlZGljdHMgMTEgQ2F0YWx5c3RzIGZvciBhIE5ldyBCdWxsIE1hcmtldA==

<p><img src="https://gimg2.gateimg.com/image/article/16999404081_14.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20APEC20discuter20degli20asset20digitali20le20false20notizie20sugli20ETF20spot20alimentano20laumento20di20XRP20di20oltre20il2010665175"><a name="Crypto Daily Digest: APEC discuterà degli asset digitali, le false notizie sugli ETF spot alimentano l’aumento di XRP di oltre il 10%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: APEC discuterà degli asset digitali, le false notizie sugli ETF spot alimentano l’aumento di <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> di oltre il 10%</h2><p>Il summit di Asia Pacific Economic Cooperation (APEC) della durata di una settimana è iniziato a San Francisco l’11 novembre.</p>
<p>La segretaria del Tesoro degli Stati Uniti, Janet Yellen, ha dichiarato nel suo discorso di apertura del meeting del 13 novembre che avrebbe discusso delle “aree di sviluppo a lungo termine” con un focus sulla sostenibilità. Terranno anche due incontri per discutere di economia dell’offerta e di beni digitali.</p>
<p>Yellen ha menzionato specificamente attività crittografiche non garantite, stablecoin e valute digitali della banca centrale. Condividere le intuizioni e collaborare con il settore privato ci consente di acquisire una comprensione più profonda degli strumenti che i decisori politici possono utilizzare per sviluppare e utilizzare in modo responsabile gli asset digitali,” ha detto Yellen.</p>
<p>Secondo il monitoraggio di Spot On Chain, FTX ha depositato ulteriori tre asset del valore di $24 milioni in Kraken e OKX nelle ultime 5 ore, tra cui 250.000 SOL ($13,5 milioni), 8,27 milioni di MATIC ($7,41 milioni) e 1500 ETH ($3,1 milioni).</p>
<p>Complessivamente, al 14 novembre, FTX e Alameda hanno trasferito 42 asset per un valore di $438 milioni all’exchange. Attualmente, FTX ha solo 3408 SOL ($179.000) di liquidità rimanente. Tuttavia, secondo i dati di CoinGecko, detengono ancora 42,2 milioni di SOL ($2,19 miliardi) in uno stato di blocco. Questi SOL saranno sbloccati solo dall’anno prossimo e rimarranno per lo più congelati fino al 2027 o 2028.</p>
<p>Secondo CoinDesk, in risposta alle precedenti notizie sull’applicazione di BlackRock per registrare iShares <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> La fiducia in Delaware, un portavoce di BlackRock ha dichiarato che i documenti regolatori circolanti online erano falsi e che BlackRock non aveva piani per lanciare XRP spot ETF. Il prezzo della valuta svizzera è salito di oltre il 10% dopo la notizia falsa, ma ora è tornato a circa $0,65.</p>
<p>BlackRock ha precedentemente presentato <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> applicazioni spot ETF alla Securities and Exchange Commission (SEC) degli Stati Uniti. Prima di presentare la sua domanda alla SEC, BlackRock ha prima registrato l’ETF pertinente nel Delaware.</p>
<p>Dopo che sono emerse false notizie secondo cui BlackRock aveva registrato Ripple (XRP) Trust sul sito di registrazione dell’azienda del Delaware, una posizione di future su XRP da 6 milioni di dollari è stata costretta a chiudersi.</p>
<p>Uno studio condotto dall’Autorità Monetaria Francese (AMF) con il supporto degli strumenti di supporto tecnico dell’UE mostra che dal 2023 il 9% degli adulti francesi possiede cripto-attività. Il sondaggio dell’AMF ha coinvolto oltre 1000 nuovi investitori al dettaglio in Francia e i risultati hanno mostrato che il 24% degli adulti francesi investe in vari strumenti finanziari. Una grande parte di esso è investita in criptovalute.</p>
<p>Sebbene gli investimenti tradizionali continuino a dominare i portafogli di investimento, la preferenza per gli asset cripto, specialmente tra i giovani, evidenzia il cambiamento generazionale delle preferenze di investimento e l’adozione graduale di soluzioni finanziarie digitali nel paese.</p>
<p>L’indagine AMF fornisce una spiegazione dettagliata: “i nuovi investitori investono meno frequentemente nel mercato azionario rispetto agli investitori tradizionali.” “Molte persone sono interessate agli asset crittografici: il 54% di loro possiede asset crittografici (il 63% dei nuovi investitori di età compresa tra i 25 ei 34 anni possiede questi asset), mentre la proporzione di investitori tradizionali è del 25%.”</p>
<p>Recentemente, a causa delle eccellenti prestazioni del mercato delle criptovalute, Alex Svanevik, fondatore della piattaforma di analisi dei dati blockchain Nansen, ha pubblicato un’analisi su Twitter di 11 catalizzatori che guidano un nuovo mercato rialzista, principalmente includendo:</p>
<ol>
<li><p>Il momento peggiore è passato, il venditore costretto a vendere è scomparso e il truffatore è imprigionato;</p>
</li><li><p>Gli ETF sul mercato spot di BTC potrebbero essere approvati entro qualche mese e le istituzioni potrebbero entrare nel mercato;</p>
</li><li><p>Le società di tecnologia finanziaria stanno entrando nel mondo della blockchain, e l’emissione di stablecoin da parte di PayPal è un “canarino” nelle miniere di carbone (un indicatore particolarmente sensibile alle fluttuazioni economiche, rappresentando un segnale). Anche altre società di tecnologia finanziaria prenderanno misure simili, e alcune banche lanceranno stablecoin nel 2024;</p>
</li><li><p>Abbiamo visto nuovi prodotti che meritano davvero di partecipare al socializzare e al gioco d’azzardo;</p>
</li><li><p>Il volume di trading NFT ha toccato il fondo un mese fa e da allora ha mostrato un trend al rialzo;</p>
</li><li><p>I giochi <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sviluppati negli ultimi due anni hanno iniziato a essere lanciati. Ne ho giocati diversi, ma ne abbiamo bisogno solo di un gioco stupefacente;</p>
</li><li><p>Gli avanzamenti tecnologici hanno reso più facile per le persone comuni unirsi, con commissioni gas inferiori su L2 e altre catene. L’astrazione dell’account significa che gli utenti possono entrare nel mondo cripto senza la necessità di mnemonici;</p>
</li><li><p>Il settore DeFi è ora alimentato da token di staking liquido (LST) e asset del mondo reale (RWA), e i rendimenti non hanno bisogno di fare affidamento su schemi Ponzi;</p>
</li><li><p>Il profitto non realizzato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di MicroStrategy supera 1 miliardo di dollari, il che permetterà all’azienda di raggiungere FOMO;</p>
</li><li><p>La politica monetaria della Federal Reserve non si è nemmeno modificata (potrebbero esserci futuri tagli dei tassi di interesse);</p>
</li><li><p>Bitcoin esperimenterà un dimezzamento l’anno prossimo.</p>
</li></ol>
<p>Inoltre, Alex Svanevik ritiene che DeFi 1.0 trae vantaggio dal mining della liquidità e dagli schemi Ponzi, che non è sostenibile. DeFi 2.0 trae vantaggio da LST e RWA, che è sostenibile. Secondo lui, DeFi 2.0 è ora iniziata.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi757622"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC327536"><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>La settimana scorsa si è chiusa intorno a $37.000, e questa settimana si è aperta con una performance elevata ma relativamente piatta. Non ci sono tendenze significative, ed è previsto che continui in modo costante, ritracciandosi al livello di $36.000. La tendenza settimanale potrebbe scendere ad un minimo di $32.850, indicando un ritracciamento rialzista.</p>
<h3 id="h3-ETH788790"><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>Il grafico giornaliero cerca di rompere la resistenza di $2.135, raggiungendo un massimo relativo che non si vedeva da un anno e mezzo. Il supporto a breve termine a $2.037 si mantiene, e se riesce a superare con successo $2.135, potrebbe raggiungere $2.381. Ciò potrebbe portare a un rally nelle altcoins, ed è consigliabile prestare attenzione al supporto a $2.030.</p>
<h3 id="h3-LINK764554"><a name="LINK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LINK</h3><p><img src="https://gimg2.gateimg.com/image/article/1699940525link.png" alt=""><br>La strategia a breve termine suggerisce di mantenere e considerare il supporto di $14,40. Gli obiettivi a lungo termine includono i massimi storici a $54,31 e i traguardi a $79,80, $107,5 e $125,89. Il consiglio conservativo è di mantenere le posizioni lunghe.</p>
<h2 id="h2-Macro20Le20aspettative20di20inflazione20si20sono20rallentate20Goldman20Sachs20prevede20un20altro20aumento20dei20tassi20di20interesse20del201220lanno20prossimo478668"><a name="Macro: Le aspettative di inflazione si sono rallentate, Goldman Sachs prevede un altro aumento dei tassi di interesse del 1-2% l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le aspettative di inflazione si sono rallentate, Goldman Sachs prevede un altro aumento dei tassi di interesse del 1-2% l’anno prossimo</h2><p>Lunedì, l’indice del dollaro USA è sceso dopo aver raggiunto i livelli 106, e alla fine ha chiuso in ribasso dello 0,132% a 105,68. Il rendimento dei titoli del Tesoro USA è diminuito, con il rendimento decennale che ha chiuso al 4,64%; Il rendimento dei titoli del Tesoro USA a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso al 5,033%. Le tre principali borse statunitensi hanno oscillato. Il Dow è salito dello 0,1%, il Nasdaq è sceso dello 0,22%, mentre l’S&amp;P 500 è sceso dello 0,08%.</p>
<p>L’oro spot è sceso prima e poi è salito, con il mercato statunitense che continua a salire, raggiungendo quasi il livello di $1950, e infine chiudendo in rialzo dello 0,3% a $1946,26 per oncia; l’argento spot si è ripreso dopo essere sceso al di sotto del livello di 22 nel trading intraday, cancellando quasi tutte le perdite intraday, e alla fine ha chiuso a $22,31 per oncia.</p>
<p>I prezzi internazionali del petrolio sono saliti a un nuovo massimo dal 7 novembre, poiché il rapporto mensile dell’OPEC allevia le preoccupazioni di mercato sulla domanda, mentre l’indagine degli Stati Uniti sulle presunte violazioni delle sanzioni russe sul petrolio da parte delle compagnie di spedizione ha sollevato preoccupazioni per possibili interruzioni dell’approvvigionamento. Il petrolio greggio WTI ha chiuso in rialzo dello 1,51% a 78,47 dollari al barile; Il petrolio greggio Brent ha chiuso in rialzo dell’1,25% a 82,63 dollari al barile.</p>
<p>Secondo un sondaggio della Federal Reserve di New York, le aspettative di inflazione in un anno diminuiranno dal 3,7% a settembre al 3,6%. Le aspettative di inflazione tra tre anni saranno del 3%, lo stesso di settembre. Le aspettative di inflazione tra cinque anni diminuiranno dal 2,8% a settembre al 2,7%.</p>
<p>Il presidente della Federal Reserve, Powell, ha dichiarato in una conferenza stampa dopo la riunione del Federal Open Market Committee (FOMC) che le aspettative di inflazione sono ancora “ben ancorate” e ha aggiunto che “è chiaro che le aspettative di inflazione sono in buone condizioni” e “non ci sono vere crepe nella corazza.”</p>
<p>Nei suoi commenti di venerdì scorso, Powell ha riconosciuto che “l’inflazione ci ha portato alcune illusioni” e ha ribadito che, se necessario, la Federal Reserve alzerà nuovamente i tassi di interesse per controllare l’inflazione.</p>
<p>Jeffrey Roach, economista capo di LPL Finance, ha affermato che “gli investitori dovrebbero prestare attenzione alle indagini più incoraggianti pubblicate dalla Fed di New York.” Ha sottolineato che il campione di indagine della Fed di New York è più ampio e completo nel riflettere il comportamento dei consumatori rispetto all’indagine dell’Università di Michigan.</p>
<p>In generale, gli economisti si aspettano ancora che l’inflazione diminuisca lentamente. La Federal Reserve di Philadelphia ha dichiarato lunedì, nell’ultima indagine trimestrale sulle previsioni professionali, che gli economisti si aspettano che il tasso di inflazione, misurato dall’indice dei prezzi delle spese dei consumatori personali (PCE), l’indicatore di inflazione preferito dalla Fed, superi ancora il 2% entro il 2024. Entro l’ultimo trimestre del 2024, il tasso di inflazione annualizzato raggiungerà il 2,3%.</p>
<p>Un altro importante test sui dati dell’inflazione sarà pubblicato martedì. Si prevede che l’IPC core, escludendo alimenti ed energia, aumenti del 4,1% a ottobre, in linea con i dati di settembre, mentre si prevede che l’inflazione generale diminuisca.</p>
<p>Il rapporto di ricerca di Goldman Sachs evidenzia che la fase difficile nella lotta all’inflazione negli Stati Uniti sembra essere passata. Una volta che il core PCE negli Stati Uniti scende sotto il 2,5%, si prevede che la Federal Reserve ridurrà i tassi di interesse di 25 punti base per trimestre dal quarto trimestre del 2024 al secondo trimestre del 2026.</p>
<p>Esistono ancora due rischi chiave: il rialzo dei prezzi del petrolio e la possibilità che qualcosa si rompa nel nuovo ambiente dei tassi di interesse. Il rischio è reale ma controllabile, in parte perché la Federal Reserve è libera di abbassare i tassi di interesse l’anno prossimo e ha abbastanza margine.</p>
<p>Il CEO di Goldman Sachs Solomon ha indicato che il rischio di una recessione economica negli Stati Uniti è significativamente diminuito rispetto a 12 mesi fa e c’è un’alta probabilità di un atterraggio morbido nell’economia. Tuttavia, la rapida crescita dell’economia asiatica attirerà sempre più fondi internazionali per investire nei mercati dei capitali regionali nel lungo termine.</p>
<p>Guardando avanti, Solomon crede che anche se l’inflazione negli Stati Uniti si è leggermente attenuata, è ancora lontana dal target di politica del 2% della Federal Reserve. Personalmente, prevede che le questioni legate all’inflazione influenzeranno l’economia locale per un certo periodo di tempo e non esclude che la Federal Reserve alzerà nuovamente i tassi di interesse quando l’inflazione riprenderà. Tuttavia, c’è poco margine per un nuovo aumento dei tassi di interesse quest’anno e potrebbero esserci uno o due rialzi l’anno prossimo. L’economia statunitense sta affrontando molti fattori di incertezza e, complessivamente, le possibilità di un atterraggio morbido sono relativamente alte.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga menzionato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>