Tm90aXppZSBxdW90aWRpYW5lIHwgUnVzc2lhIHBlciBsZWdpc2xhcmUgc3VsbGUgY3JpcHRvdmFsdXRlOyBPUkRJIGUgMTAwMFNBVFMgaGFubm8gcmVnaXN0cmF0byB1biBhdW1lbnRvIGdpb3JuYWxpZXJvIGRpIG9sdHJlIGlsIDQwJTsgQmxhc3QgZSBTdWkgTmV0d29yayBUVkwgcmFnZ2l1bmdvbm8gbnVvdmkgbWFzc2ltaQ==

2023-12-26, 04:03

<p><img src="https://gimg2.gateimg.com/image/article/17035744251_18.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Si20prevede20che20la20Russia20legiferi20per20le20criptovalute20allinizio20dellanno20prossimo20ORDI20ha20registrato20un20aumento20giornaliero20superiore20al2040628686"><a name="Crypto Daily Digest: Si prevede che la Russia legiferi per le criptovalute all’inizio dell’anno prossimo, ORDI ha registrato un aumento giornaliero superiore al 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Si prevede che la Russia legiferi per le criptovalute all’inizio dell’anno prossimo, ORDI ha registrato un aumento giornaliero superiore al 40%</h2><p>Ieri, Anatoly Aksakov, presidente del Comitato del mercato finanziario della Duma di Stato russa, ha detto: “A causa delle dimensioni significative del mercato delle criptovalute in Russia, i principali partecipanti alla cripto-mineraria e alla circolazione sperano di regolamentarlo e sono pronti a pagare le tasse. Pertanto, mi aspetto che la legislazione sulle criptovalute diventi legge nella prima metà del 2024.”</p>
<p>Guidato da fattori come l’approvazione possibile di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli spot ETF, i tagli previsti dei tassi di interesse da parte della Federal Reserve e una maggiore trasparenza regolamentare fanno pensare agli analisti che nel 2024 gli investitori istituzionali mostreranno un interesse più positivo nel settore delle criptovalute e le istituzioni finanziarie potrebbero aumentare la loro attività nel mercato delle criptovalute.</p>
<p>Dal 2023, l’attività di trading degli investitori istituzionali è aumentata. Luuk Strijers, Chief Business Officer di Deribit, ha dichiarato che i partecipanti provenienti dai mercati tradizionali saranno sempre più coinvolti nel mercato delle criptovalute nel 2024.</p>
<p>Gli analisti di Bitfinex ritengono che il principale catalizzatore per le istituzioni finanziarie tradizionali per partecipare maggiormente al mercato delle criptovalute sia l’approvazione degli ETF spot su Bitcoin. Ciò fornirà agli investitori istituzionali un modo regolamentato per scommettere sul prezzo della criptovaluta più grande del mondo.</p>
<p>Gli analisti di Bitfinex suggeriscono che i potenziali tagli ai tassi di interesse nel 2024 incoraggeranno gli investitori istituzionali a correre rischi. Questa maggiore preferenza per gli asset rischiosi potrebbe alla fine influenzare Bitcoin. Gli analisti di Bitfinex hanno aggiunto: “I tagli dei tassi di interesse potrebbero rendere gli asset rischiosi come <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> più attraenti per gli investitori istituzionali che cercano rendimenti più elevati in un ambiente a basso tasso di interesse.”</p>
<p>Secondo Bitfinex, gli investitori saranno incoraggiati da una maggiore trasparenza regolamentare nell’anno a venire. Gli analisti di Bitfinex sostengono che l’aspetto più importante della trasparenza regolamentare è l’approvazione degli ETF spot di Bitcoin, che forniranno uno strumento di investimento regolamentato e più facile da ottenere per gli investitori al dettaglio e istituzionali.</p>
<p>Secondo l’analisi recente di Glassnode, il ruolo delle stablecoin nella dinamica di mercato è significativamente cambiato rispetto al ciclo precedente, e sono diventate la valuta di riferimento preferita dai trader e la principale fonte di liquidità di mercato. Inoltre, ottobre ha segnato la prima espansione dell’offerta di stablecoin dal marzo 2022, il che potrebbe essere un segno di un rinnovato interesse degli investitori.</p>
<p>Secondo PolkaWorld, Gavin Wood, co-fondatore di <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, ha pubblicato la sua prospettiva per il 2024 nel riassunto annuale di Polkadot, affermando che <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> affronterà una serie di importanti sviluppi e lavoro intenso nel nuovo anno, tra cui quattro imminenti infrastrutture chiave: agile Coretime, catena parallela su richiesta <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Snowbridge (tecnologia di ponte che collega Polkadot e Ethereum) e <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> Bridge (tecnologia che collega Polkadot e la sua rete sorella Kusama). Inoltre, c’è una quinta tecnologia imminente, ovvero l’espansione elastica, che si prevede verrà implementata nel 2024.</p>
<p>Influenzato da fattori favorevoli, secondo i dati di mercato di Gate.io, DOT è salito sopra i $9,5, puntando direttamente a $10, e ora è riportato a $9,38, con un aumento del 7,6% nelle ultime 24 ore.</p>
<p>In termini di fluttuazioni di mercato di altri token popolari, i guadagni intraday di ORDI e 1000SATS sono stati rispettivamente del 44,77% e del 41,58%. Secondo i dati di mercato di Gate.io, ORDI ha brevemente superato i $78 e ora si sta scambiando a $76,12. Aumento del 44,77% nelle ultime 24 ore; 1000SATS è salito a $0,000889 e ora è segnalato a $0,0008717, con un aumento del 41,58% nelle ultime 24 ore.</p>
<p>Secondo i dati di DeBank, l’indirizzo del contratto Blast della rete Layer 2 di Pacman, fondatore di Blur, attualmente detiene un valore totale degli asset di oltre 1 miliardo di dollari, raggiungendo 1,03 miliardi di dollari. Circa 918 milioni di dollari in ETH sono stati depositati nel protocollo Lido e 107 milioni di dollari in asset sono stati depositati nel protocollo Maker.</p>
<p>Inoltre, il TVL della rete di Sui ha superato anche i 200 milioni di dollari, raggiungendo un massimo storico. Dal settembre 2023, il TVL della rete è cresciuto di quasi il 500%.</p>
<p>In termini di NFT, i dati di Cryptoslam.io mostrano che il volume delle transazioni NFT è diminuito del 12,26% la scorsa settimana, raggiungendo i 463,87 milioni di dollari. La scorsa settimana il numero di acquirenti NFT è aumentato del 72,05% e il numero di venditori è aumentato del 56,61%.</p>
<p>Nonostante una diminuzione del 13,71% rispetto alla settimana precedente, gli NFT sulla catena di Bitcoin sono ancora al primo posto con un volume di transazioni settimanale di $265,61 milioni, che rappresenta il 57,25% di tutte le transazioni NFT della scorsa settimana. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Il volume di trading NFT on chain di Binance ($88.42 milioni) è salito al secondo posto, mentre il volume di trading settimanale NFT on chain di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ($75.91 milioni) è sceso al terzo posto.</p>
<p>Tra le prime dieci serie NFT principali in termini di volume di transazioni della settimana scorsa, 9 provengono dalla catena di Bitcoin. La serie NFT <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Open Solmap si classifica al quinto posto per volume di transazioni settimanale ($1,04 milioni) sulla catena.</p>
<p>Anche se il volume di trading si è rallentato, il mercato dei token nel settore dei giochi blockchain ha mostrato una tendenza generale al rialzo. Secondo i dati di mercato, c’è stata una tendenza generale al rialzo dei token di gioco blockchain, con AXS che ha registrato un aumento del 30,31% nelle ultime 24 ore e attualmente offre un prezzo di $10,5; MBOX ha registrato un aumento del 23,03% nelle ultime 24 ore ed è attualmente quotato a $0,4; AGLD ha registrato un aumento del 19,44% nelle ultime 24 ore ed è attualmente quotato a $1,446; L’aumento nelle ultime 24 ore di VOXEL è stato del 13,32% e la quotazione attuale è di $0,2438; L’aumento nelle ultime 24 ore di SLP è stato del 11,68% e la quotazione attuale è di $0,0035.</p>
<p>Rispetto ai 33,3 miliardi di dollari investiti nel 2022, il capitale di rischio criptato nel 2023 è crollato del 68% a 10,7 miliardi di dollari. Tuttavia, gli investimenti totali nel 2023 superano comunque il precedente mercato ribassista, superando i 6,4 miliardi di dollari investiti nel 2019 e nel 2020. La maggior parte degli investimenti è avvenuta nel primo semestre dell’anno, con una leggera diminuzione nella seconda metà, nonostante un aumento degli investimenti a novembre.</p>
<p>Vale la pena notare che la proporzione di transazioni allocate a start-up pre-servizio, seed e A-round nel 2023 è aumentata, mentre le transazioni nelle fasi medie e tardive sono diminuite rispetto all’anno precedente. Nonostante la frenata economica del 2023, l’investimento totale per l’anno ha comunque superato il precedente mercato orso. L’importo degli investimenti dal 2019 al 2020 è stato di 6,4 miliardi di dollari.</p>
<p>Il numero delle transazioni di venture capital criptato è diminuito anche nel 2023. Quest’anno ci sono state un totale di 1819 transazioni, una diminuzione del 32% rispetto alle 2671 del 2022. Nel complesso, il volume degli scambi nel 2023 è rimasto più alto rispetto al volume mensile degli scambi nel 2020 e si è avvicinato al volume degli scambi nel 2021. Dalla distribuzione degli investimenti di fase, la maggior parte dei fondi <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> per finanziare start-up pre-seed, seed e pre A-round nel 2023, mentre l’attività delle start-up di medio e tarda fase è relativamente bassa, il che è coerente con la tendenza del 2022.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi452638"><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-BTC409644"><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/1703574507BTC.png" alt=""><br>La scorsa settimana si è chiusa sopra i $42.500 e questa mattina continua a testare l’asse del canale di mezzo. Questa settimana si prevede che testerà due obiettivi di resistenza: $45.345 e $47.990. Il supporto rimane forte a $40.280 e $38.399, indicando una continuazione dell’oscillazione ad alto livello nel medio termine.</p>
<h3 id="h3-ETH932957"><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/1703574525ETH.png" alt=""><br>A breve termine, si osserva un trend discendente del triangolo di quattro ore. Si consiglia di prestare attenzione alla resistenza alta a breve termine di $2.381. Una rottura potrebbe portare a un movimento verso l’alto verso $2.489 e $2.838. In caso contrario, potrebbe verificarsi un retest del supporto a $2.135. L’outlook a lungo termine rimane rialzista.</p>
<h3 id="h3-GT736578"><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/1703574542GT.png" alt=""><br>Il grafico settimanale segnala l’inizio della seconda fase di un mercato rialzista. Il supporto a breve termine è sulla linea bianca, mentre il supporto a lungo termine converge intorno a $2.88. Prevedendo un movimento al rialzo anticipato nel settore delle valute della piattaforma, i prezzi obiettivo sono fissati a $12.877, $18.977, $28.58 e $44.99. Si consiglia di tenere a lungo termine.</p>
<h2 id="h2-Macro20mercato20chiuso20per20le20vacanze20di20Natale20come20investire20in20un20portafoglio20nel202024734929"><a name="Macro: mercato chiuso per le vacanze di Natale, come investire in un portafoglio nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: mercato chiuso per le vacanze di Natale, come investire in un portafoglio nel 2024</h2><p>Lunedì, a causa delle vacanze di Natale, l’indice del dollaro USA, i bond USA, l’oro spot, l’argento spot, il petrolio greggio WTI, il petrolio greggio Brent, le azioni USA, le azioni europee e le azioni di Hong Kong sono rimasti chiusi per un giorno.</p>
<p>In termini di tagli dei tassi di interesse, secondo l’ultima “Federal Reserve Observation” del CME del 26 dicembre, la probabilità che la Federal Reserve mantenga i tassi di interesse nell’intervallo del 5,25% -5,50% nel febbraio del prossimo anno è dell’83,5% e la probabilità di un taglio dei tassi di 25 punti base è del 16,5%. La probabilità di mantenere invariati i tassi di interesse entro marzo del prossimo anno è del 6,7%, la probabilità di un taglio cumulativo di 25 punti base è del 78,1% e la probabilità di un taglio cumulativo di 50 punti base è del 15,2%.</p>
<p>Il 2023 sta finendo e guardiamo al 2024 come un anno pieno di sfide e opportunità per gli investitori, che coinvolgono molteplici aspetti come l’economia degli Stati Uniti, i mercati di investimento e le criptovalute.</p>
<p>Iniziamo col dare un’occhiata ai suggerimenti degli esperti su come prepararsi al meglio per il 2024, nonché alle loro opinioni sul mercato azionario, sui bond, sulle criptovalute e sui portafogli di investimento.</p>
<p>Innanzitutto, considera il tuo livello di rischio. Gli investitori devono esaminare quanto rischio hanno assunto nel loro portafoglio di investimenti, poiché il 2024 potrebbe affrontare alcuni ostacoli potenziali, tra cui una diminuzione del mercato del lavoro, tassi di interesse elevati e inflazione sostenuta. Pertanto, mantenere prudenza e essere in grado di sopportare una bassa latenza è una scelta saggia.</p>
<p>In secondo luogo, non affrettarsi a vendere azioni e obbligazioni. Le azioni e le obbligazioni sono ancora probabilmente a ricevere rendimenti consistenti l’anno prossimo, e la riduzione dei tassi di interesse della Federal Reserve potrebbe stimolare un rimbalzo del mercato azionario.</p>
<p>Terzo, non abbandonare la struttura tradizionale del portafoglio d’investimento composta per il 60% da azioni e per il 40% da obbligazioni. Quando i tassi di interesse raggiungono o si avvicinano al picco, la parte del portafoglio d’investimento costituita da obbligazioni può alla fine avere delle buone performance. Pertanto, non rinunciare a questo portafoglio ora, ma diversifica aggiungendo una miscela di azioni internazionali, obbligazioni del tesoro degli Stati Uniti e obbligazioni societarie.</p>
<p>Inoltre, gli investitori devono rivalutare le loro opzioni di liquidità. Un tasso di interesse più elevato significa che gli investitori hanno ottenuto consistenti rendimenti in contanti, ma se la Federal Reserve riduce i tassi di interesse, la situazione potrebbe cambiare. Pertanto, è suggerito considerare l’acquisto di obbligazioni del Tesoro statunitense a uno o tre anni per bloccare il rendimento.</p>
<p>Infine, disporre in anticipo le criptovalute. Aggiungere una piccola porzione di criptovaluta a un portafoglio di investimento può aiutare a ottenere una diversificazione. Bitcoin ha sperimentato un aumento su larga scala quest’anno, con il suo prezzo più che raddoppiato. Inoltre, i Fondi Traded su Bitcoin (ETF) potrebbero essere finalmente rilasciati l’anno prossimo, il che renderà più facile investire in criptovalute.</p>
<p>L’anno 2024 è pieno di sfide e opportunità per gli investitori, e devono essere cauti e fare riferimento ai consigli degli esperti per condurre la propria ricerca, al fine di prendere decisioni di investimento più razionali.</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 citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>