Tm90aXppZSBxdW90aWRpYW5lIHwgSG9uZyBLb25nIHJlZ29sYSBsYSBzdXBlcnZpc2lvbmUgZGVnbGkgYXNzZXQgdmlydHVhbGkgZGVpIGZvbmRpIHB1YmJsaWNpOyBTT0wsIEFWQVggZSBITlQgZ3VpZGFubyBsYSBjcmVzY2l0YSBkZWxsZSBjcmlwdG92YWx1dGUgbmVsIDIwMjM7IFNPTCDDqCBzYWxpdG8gZGkgb2x0cmUgaWwgNzAwJSB

2023-12-27, 03:51

<p><img src="https://gimg2.gateimg.com/image/article/17036574771_19.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Hong20Kong20regola20la20supervisione20degli20asset20virtuali20nei20fondi20pubblici20SOL20ha20guidato20la20crescita20della20valuta20nellera202023458911"><a name="Crypto Daily Digest: Hong Kong regola la supervisione degli asset virtuali nei fondi pubblici, SOL ha guidato la crescita della valuta nell’era 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Hong Kong regola la supervisione degli asset virtuali nei fondi pubblici, SOL ha guidato la crescita della valuta nell’era 2023</h2><p>Di recente, secondo China Fund News, la Commissione di regolamentazione dei titoli di Hong Kong ha emesso un avviso in cui si afferma che per i prodotti di fondi pubblici con attività virtuali contabili superiori al 10%, le società di gestione, le strategie di investimento pertinenti e i custodi dei prodotti devono soddisfare le condizioni corrispondenti. La società di gestione deve avere personale con esperienza nella gestione di attività virtuali. Secondo le normative attuali, in generale, le istituzioni che detengono la targa n. 9 della Commissione di regolamentazione dei titoli di Hong Kong non devono superare il 10% dei loro portafogli di fondi in termini di attività virtuali.</p>
<p>L’ultima comunicazione afferma chiaramente che se la proporzione di asset virtuali supera (o si prevede di superare) il 10%, l’agenzia di gestione deve richiedere l’approvazione alla Commissione per i Valori Mobiliari e i Futures di Hong Kong prima che i prodotti pertinenti possano essere venduti agli investitori di Hong Kong.</p>
<p>Questa comunicazione intitolata “Riconoscimento della Commissione per i Valori Mobiliari e i Futures di Hong Kong degli Investimenti in Attività Virtuali” stabilisce chiaramente che in primo luogo, le società che gestiscono fondi di attività virtuali (con attività virtuali che rappresentano più del 10% dei fondi) devono avere un buon registro di conformità, e almeno un dipendente della società deve avere esperienza nella gestione di attività virtuali o prodotti correlati. La società di gestione deve rispettare i requisiti esistenti o nuovi dell’autorità di regolamentazione per le società di gestione di attività virtuali.</p>
<p>Ieri, la società di ricerca cripto Delphi Digital ha pubblicato “Il futuro di DeFi nel 2024”. Viene menzionato il modello di staking di liquidità di base. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è difficile apportare cambiamenti sostanziali; RWA diventa silenziosamente una delle aree di maggiore successo della criptovaluta nel 2023, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V4, <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> X e altri DEX diventeranno il tema del 2024, Rollups è una scelta saggia per varie applicazioni, e IRD potrebbe diventare una delle narrazioni popolari della criptovaluta.</p>
<p>Tra questi, Delphi Digital ritiene che Atm, pendlefi, Notional Finance e iporio siano protocolli IRD sostenibili.</p>
<p>I derivati dei tassi di interesse (IRD), anche noti come derivati dei tassi di interesse, sono contratti finanziari il cui valore è basato su un tasso di interesse di riferimento o su un asset che produce interessi. Questo tipo di derivato include future sui tassi di interesse, opzioni, swap, ecc. Sono strumenti utilizzati per coprire il rischio o speculare sulle variazioni dei tassi di interesse nel mercato.</p>
<p>I derivati sui tassi di interesse possono essere divisi in due categorie: lineari e non lineari. I derivati lineari come i tassi di interesse swap e futures, i cui pagamenti o rendimenti sono direttamente correlati al tasso di interesse di riferimento; I derivati non lineari, come le opzioni sui tassi di interesse, forniscono il diritto di acquistare o vendere un certo asset in specifiche condizioni, ma non un obbligo.</p>
<p>Il 26 dicembre, secondo CoinDesk, nel 2023, blockchain Layer-1 <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>(SOL) ha preso il comando degli aumenti di prezzo dei token, seguito da vicino da <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> (AVAX), <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Pile</a> (STX) e <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Elio</a>(HNT).</p>
<p>Solana ha registrato un aumento significativo a partire dalla metà di ottobre, con un tasso di crescita superiore al 700% dall’inizio di quest’anno. Brian Rudick, stratega senior di GSR, ha affermato: ‘dopo il fallimento di FTX, la sopravvivenza di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> aveva effettivamente dei problemi. Con l’aumento delle attività on-chain, una nuova comprensione della sua tecnologia innovativa e diversi air drop di alto profilo, invece ha prosperato’.</p>
<p>Il token HNT di <a href="/price/helium-hnt" target="_blank" class="blog_inner_link">Helium</a> ha ottenuto anche un considerevole guadagno nel 2023, con la maggior parte nel mese di dicembre. Dopo l’ingresso dell’azienda nel settore mobile, HNT è aumentato del 500% durante l’anno. Per Avalanche, molti partner istituzionali hanno contribuito ad aumentare il valore dei token e AVAX è aumentato del 300% finora quest’anno. Il token nativo <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> (STX) di Stacks Network è aumentato del 623% durante l’anno. Con il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La follia degli ordinali e la crescita continua del TVL sul protocollo, il token ha registrato un aumento significativo a marzo. Secondo i dati di DeFiLlama, il TVL della Stacks Network è aumentato in modo significativo durante l’anno, passando da $6 milioni a gennaio a $50 milioni.</p>
<p>Rudick ha dichiarato di aspettarsi che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> continuino a salire nel nuovo anno, in parte grazie alla possibilità di approvazione degli ETF Bitcoin degli Stati Uniti e all’aiuto degli afflussi di capitali. Ha anche sottolineato che “vediamo una nuova ondata di utenti di blockchain in identità decentralizzate basate su piani o interessi annunciati dalla Cina, dall’Unione Europea, dal Brasile e da altri paesi”. Martin ha detto che oltre alla focalizzazione sugli ETF all’inizio del nuovo anno, gli asset del mondo reale diventeranno anche un’area degna di attenzione. Alcune fondazioni correlate sono state istituite quest’anno, ma la società mainstream non è ancora al passo.</p>
<p>A livello dati, le statistiche di Coinalyze mostrano che la quota di mercato delle posizioni aperte nei futures di Bitcoin è diminuita dal 50% al 38% nei due mesi scorsi, il livello più basso degli ultimi due anni. Sembra che i fondi di mercato si stiano spostando verso Altcoins, il che spiega anche perché la posizione dominante di BTC nelle posizioni aperte futures sta diminuendo.</p>
<h2 id="h2-Le20principali20tendenze20dei20token20di20oggi710612"><a name="Le principali tendenze dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le principali tendenze dei token di oggi</h2><h3 id="h3-BTC284134"><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/1703657516BTC.png" alt=""><br>Il mercato ha sperimentato varie correzioni questa settimana e nella sessione di ieri sera ha nuovamente rotto al di sotto della linea di mezzo. Il trend di medio termine sembra ribassista, con livelli di supporto chiave a $40.280 e $38.399. La chiusura mensile è ottimistica, puntando verso il livello di $40.000.</p>
<h3 id="h3-ETH755698"><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/1703657536ETH.png" alt=""><br>Nel breve termine, il grafico a quattro ore mostra un trend a triangolo discendente. Si consiglia di monitorare se la resistenza a $ 2.381 viene superata per un movimento al rialzo. L’obiettivo ribassista di ieri ha raggiunto con precisione il livello di supporto a $ 2.180. Se questo livello si mantiene senza rotture, ci si aspetta una continua tendenza al rialzo che formerà un pattern testa e spalle. In caso di rottura, il prossimo obiettivo è di 2.135$ per un nuovo test del supporto.</p>
<h3 id="h3-INJ770582"><a name="INJ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>INJ</h3><p><img src="https://gimg2.gateimg.com/image/article/1703657553INJ.png" alt=""><br>Il grafico giornaliero mostra segni di una struttura di topping e la rottura di ieri al di sotto del supporto di $37.54 suggerisce un continuo test di $32.32. Nel medio e lungo termine, gli outlook positivi sono mantenuti a $61.084, $97.616 e $117.48. Il trend complessivo appartiene al mercato rialzista di medio termine e si consiglia di mantenere il possesso come strategia principale.</p>
<h2 id="h2-Macro20le20azioni20statunitensi20hanno20chiuso20collettivamente20in20rialzo20dopo20il20ritorno20dalla20festivit20le20banche20dinvestimento20hanno20opinioni20diverse20sul20taglio20dei20tassi20dinteresse20dellanno20prossimo806790"><a name="Macro: le azioni statunitensi hanno chiuso collettivamente in rialzo dopo il ritorno dalla festività; le banche d’investimento hanno opinioni diverse sul taglio dei tassi d’interesse dell’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: le azioni statunitensi hanno chiuso collettivamente in rialzo dopo il ritorno dalla festività; le banche d’investimento hanno opinioni diverse sul taglio dei tassi d’interesse dell’anno prossimo</h2><p>Martedì l’indice del dollaro statunitense ha continuato il suo trend al ribasso e è sceso a un minimo intraday di 101,45, chiudendo infine in calo dello 0,23% a 101,47; Il rendimento del Tesoro statunitense decennale era vicino alla stabilità al 3,897%, mentre il rendimento del Tesoro statunitense biennale, che è più sensibile al tasso di politica della Federal Reserve, ha chiuso al 4,356%.</p>
<p>Beneficiando della debolezza dell’indice del dollaro americano e dei rendimenti dei titoli statunitensi, l’oro fisico ha continuato a salire e ha raggiunto brevemente un massimo intraday di $2069.14 durante le negoziazioni negli Stati Uniti, chiudendo infine in rialzo dello 0.73% a $2067.97/oncia; l’argento fisico è salito dello 0.16% chiudendo a $24.23 per oncia.</p>
<p>A causa dell’unico attacco alle navi del Mar Rosso, il mercato ha sollevato preoccupazioni riguardo all’interferenza nella spedizione, che ha portato ad un significativo aumento dei prezzi del petrolio entro due giorni. Il petrolio greggio WTI è salito ad un massimo intraday di $76,14 nella sessione di trading, ma ha ceduto parte dei suoi guadagni nella sessione di trading serale, chiudendo infine in rialzo del 2,58% a $75.28 al barile; il petrolio greggio Brent è salito fortemente sopra la soglia dei $80 e ha chiuso infine in rialzo del 2,23% a $80,63 al barile.</p>
<p>Il lungo weekend del mercato azionario statunitense è terminato e i tre principali indici azionari hanno chiuso in rialzo. Il Dow Jones Industrial Average è salito dello 0,43%, l’indice S&amp;P 500 è salito dello 0,42%, avvicinandosi al massimo storico di gennaio dello scorso anno, e il Nasdaq è salito dello 0,54%.</p>
<p>Il 2023 è stato un anno turbolento per il mercato, e gli analisti delle banche d’investimento nel 2024 hanno opinioni contrastanti sul mercato, alcuni sono ottimisti e altri hanno un atteggiamento pessimista. Il principale <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> è che l’economia degli Stati Uniti si rafforzerà e la Federal Reserve ridurrà i tassi di interesse; le persone pessimiste credono che sebbene l’inflazione sembri sotto controllo al momento, le preoccupazioni delle persone sull’inflazione potrebbero riprendersi la prossima primavera. I fattori che causano problemi sono i tassi di interesse stessi, i problemi della catena di approvvigionamento e i prezzi elevati di materiali, beni e servizi.</p>
<p>Tra questi, John Stoltzfus, Chief Investment Strategist di Oppenheimer, prevede che la Federal Reserve non taglierà i tassi di interesse almeno fino alla seconda metà del prossimo anno e, se l’inflazione diventa più appiccicosa, potrebbe prendere provvedimenti entro e non oltre il quarto trimestre. Alcuni operatori di mercato prevedono una serie di tagli dei tassi di interesse nel primo trimestre. A nostro avviso, la metà di loro appare eccessivamente ottimista. Dopo 11 rialzi dei tassi e 3 “salti”, la pausa della Federal Reserve nei rialzi dei tassi sarà probabilmente più lunga di quanto molti si aspettassero.</p>
<p>L’istituto di ricerca BCA ritiene che se la Federal Reserve riduce rapidamente i tassi di interesse, il mercato azionario potrebbe evitare una forte diminuzione l’anno prossimo, ma l’istituto non si aspetta una rapida diminuzione dell’inflazione. Il BCA ha sottolineato che “siamo ancora nel campo dell’inflazione in rallentamento, ma non ci aspettiamo che il suo rallentamento sia abbastanza rapido”, al punto che la Federal Reserve e la Banca Centrale Europea non riescono a tagliare i tassi di interesse tempestivamente per evitare un significativo aumento dei tassi di disoccupazione. A meno che non sia imminente una recessione economica o che l’inflazione collassi completamente, è improbabile che la Federal Reserve riduca i tassi di interesse prima dell’estate prossima.</p>
<p>L’anno scorso, in questo periodo, il mercato scommetteva che la Federal Reserve avrebbe aumentato i tassi di interesse di circa 50 punti base entro la metà del 2023 e avrebbe allentato alcune politiche di restrizione entro la fine di quest’anno. Di conseguenza, la Federal Reserve ha aumentato i tassi di interesse il doppio di quanto previsto dal mercato e la politica deve ancora essere allentata.</p>
<p>In questo momento, anche se l’economia degli Stati Uniti, in particolare il mercato del lavoro, sembra avere una vasta resilienza, i trader di tassi di interesse credono ancora fermamente che l’inflazione sia diventata una ‘decorazione nel retrovisore’, quindi attualmente stanno considerando molti fattori per rilassare le politiche. La Federal Reserve stima che i tassi di interesse delle politiche possano essere ridotti di 75 punti base nel 2024, ma il mercato ritiene che un doppio rilassamento sia del tutto realizzabile. Aspetteremo e vedremo come si svilupperà il mercato.</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 ripostare dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>