Q3J5cHRvIEZ1bmRzIDEwMTogQ2xhc3NpZmljYXppb25lIGRlaSBGb25kaQ==

2023-02-03, 06:31

<p><img src="https://gimg2.gateimg.com/image/article/167540508711.png" alt=""><br>Come veterano esperto nel trading di criptovalute e nello sviluppo delle infrastrutture front-to-back office, il team di 1Token ha preparato una serie di articoli per condividere esperienze e approfondimenti nella gestione dei fondi criptati. Questo articolo servirà come introduzione iniziale, coprendo i tipici tipi di fondi criptati nel mercato delle criptovalute sempre più regolamentato di oggi.</p>
<h2 id="h2-Prelude20Dai20Fondi20Tradizionali20ai20Fondi20Crypto948002"><a name="Prelude: Dai Fondi Tradizionali ai Fondi Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prelude: Dai Fondi Tradizionali ai Fondi Crypto</h2><p>In generale, un fondo è un pool di capitale allocato per uno scopo specifico.</p>
<p>Le fonti comuni di capitale includono trust, fondi sovrani, società assicurative e vari tipi di fondazioni. Tuttavia, le decisioni di investimento sono prese dai GP del fondo, che sono gestori di asset professionisti che mirano a generare rendimenti più elevati allocando il capitale del fondo sia nei mercati primari (venture capital, private equity) che in quelli secondari.</p>
<p>I fondi crittografici si stanno sviluppando da anni. Dal 2014, quando sono emersi per la prima volta i fondi crypto, al 2021, quando i primi fondi crypto statunitensi <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Con il lancio degli ETF, un numero crescente di hedge fund e family office ha investito in asset cripto. Il mercato rialzista del 2020-2021 ha ulteriormente aumentato la capitalizzazione di mercato totale dei fondi cripto a oltre $62 miliardi. Oggi, sempre più istituzioni finanziarie tradizionali (e persino non finanziarie) stanno entrando nel business delle criptovalute attraverso la loro prima allocazione verso asset correlati alle cripto.<br><img src="https://gimg2.gateimg.com/image/article/167540525022.png" alt=""><br>Sebbene i fondi criptati siano simili ai fondi tradizionali nella struttura dei fondi e nella classificazione di base del portafoglio, l’infrastruttura blockchain decentralizzata rende gli asset criptati diversi dagli asset finanziari tradizionali come azioni e obbligazioni e affrontano una maggiore varietà e un maggior numero di tipi/strumenti di asset, sedi di negoziazione e strategie e requisiti IT più avanzati. Inoltre, ci sono molte sfumature degne di nota sul controllo del rischio, il calcolo dei KPI del fondo e l’audit del fondo.</p>
<p>In quanto veterano esperto nel trading di criptovalute e nello sviluppo dell’infrastruttura front-to-back-office, il team di 1Token ha preparato una serie di articoli per condividere esperienze e approfondimenti nella gestione dei fondi criptati. Questo articolo servirà come introduzione iniziale, coprendo i tipici tipi di fondi criptati nel mercato criptato sempre più regolamentato di oggi.</p>
<p>I punti chiave nella gestione e nelle operazioni dei fondi per vari tipi di fondi, gestori e terze parti, nonché l’analisi approfondita delle caratteristiche di ognuno saranno trattati in futuri articoli.</p>
<h2 id="h2-Classificazione20dei20fondi20crittografici210820"><a name="Classificazione dei fondi crittografici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Classificazione dei fondi crittografici</h2><p>I fondi criptati possono essere categorizzati in fondi di mercato primario e fondi di mercato secondario.</p>
<p>I fondi di mercato primario (come VC, Fondi di semina/crescita, ecc.) investono principalmente in progetti legati alla blockchain, inclusi progetti pre-ITO (Initial Token Offering), progetti post-ITO che non sono ancora stati quotati sui principali scambi (Binance, FTX, Coinbase, ecc.), nonché progetti di token non fungibili (NFT).</p>
<p>I fondi del mercato secondario, invece, si concentrano sugli investimenti in criptovalute e sui loro derivati, che possono essere scambiati direttamente sugli exchange o over the counter (OTC). Oltre alle classificazioni per fondi pubblici/privati, aperti/chiusi come i fondi tradizionali, i fondi crittografici possono essere classificati in base alla strategia di investimento, alla frequenza di trading e alla fonte di capitale. A seconda del tipo di fondo specifico, sono necessari diversi livelli di infrastruttura e risorse IT nelle operazioni quotidiane del fondo.</p>
<h2 id="h2-Fondo20Crypto20per20Strategia20di20Investimento395316"><a name="Fondo Crypto per Strategia di Investimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondo Crypto per Strategia di Investimento</h2><p>Le strategie tipiche includono Beta (passiva), Neutral/Alpha (ad alta frequenza e delta neutro), Attiva (gestita attivamente) e Yield (reddito fisso).</p>
<p>● Strategia passiva: i rendimenti sono confrontati con il movimento complessivo del mercato delle criptovalute. Le strategie tipiche includono il monitoraggio delle prestazioni di una singola criptovaluta o di un paniere di criptovalute mainstream (BTC ed ETH).</p>
<p>● Strategia neutrale/Alpha: i rendimenti sono ottenuti dalla volatilità di mercato, utilizzando coperture derivate per mantenere il Delta a zero nel lungo termine. Le tipiche strategie neutrali includono arbitraggio e market making.</p>
<p>Le performance delle strategie attive sono determinate dal giudizio soggettivo dei gestori sui movimenti dei prezzi (ad esempio, lungo quando il prezzo è basso e corto quando è alto). Le posizioni vengono aggiustate in base alla differenza tra il prezzo di mercato e il prezzo soggettivo, ottenendo un alpha aggiuntivo rispetto al rendimento beta generato dal movimento di mercato.</p>
<p>Strategia di rendimento: Sebbene attualmente non esista un mercato standard per i bond cripto, un fondo di rendimento può investire in ‘bond non standard’ (come prestiti OTC e prime brokerage), che sono modelli popolari che generano rendimenti fissi simili ai bond attraverso l’ottenimento di interessi netti dai prestiti in contropartita. Le operazioni dei fondi di rendimento richiedono generalmente un controllo del rischio più rigoroso data la drastica fluttuazione dei collaterali denominati in cripto (come Luna e UST a maggio 2022). Un’altra strategia comune per i fondi di rendimento è partecipare alle attività finanziarie DeFi basate su smart contract sulla blockchain che hanno proprietà a reddito fisso. Ad esempio, il farming di rendimento su smart contract DeFi (non applicabile nei mercati finanziari tradizionali) consente ai gestori dei fondi di prestare, prendere a prestito o mettere in gioco monete per guadagnare interessi e speculare sulle oscillazioni dei prezzi.</p>
<h2 id="h2-Fondo20criptovalutario20in20base20alla20frequenza20di20trading164691"><a name="Fondo criptovalutario in base alla frequenza di trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondo criptovalutario in base alla frequenza di trading</h2><p>Le strategie tipiche includono bassa frequenza (trading manuale), media frequenza (trading semi-algo) e alta frequenza (trading quantitativo).</p>
<p>● Trading manuale: gli ordini vengono inseriti manualmente sui siti web/app degli scambi, tramite OTC o tramite terminali di trading forniti da infrastrutture IT.</p>
<p>● Trading semi-algo: gli ordini vengono inseriti impostando manualmente l’importo totale dell’ordine, e vengono eseguiti tramite programmi pre-impostati (TWAP, VWAP, PEG, ecc.).</p>
<p>● Trading quantitativo: gli ordini vengono inseriti dai programmi, i quali si connettono agli scambi tramite API.</p>
<p>Ci sono diverse distinzioni importanti tra il trading nel mercato delle criptovalute e il mercato finanziario tradizionale:</p>
<ol>
<li><p>le criptovalute possono essere scambiate24⁄7</p>
</li><li><p>le stesse coppie di valute (ad esempio BTC/USD Spot) possono essere scambiate in più piattaforme (exchange/OTC). In totale ci sono centinaia di exchange di criptovalute centralizzati (Binance, FTX, Deribit, OKX, ecc.) e decentralizzati (Uniswap e Pancakeswap, ecc.) in tutto il mondo</p>
</li><li><p>I fondi crittografici possono ottenere direttamente quotazioni di mercato gratuite e inserire ordini tramite scambi (anche HFTs) anziché dover negoziare attraverso intermediari</p>
</li></ol>
<p>Queste tre distinzioni portano a maggiori opportunità di arbitraggio per le strategie Alpha nel mercato crittografico (ad es. arbitraggio tra scambi). Nei casi tipici, i gestori di fondi adotteranno diverse frequenze di trading in base al proprio obiettivo di rendimento, strategia di trading e capacità IT.</p>
<h2 id="h2-Fondo20Crypto20da20Fonte20di20Capitale364264"><a name="Fondo Crypto da Fonte di Capitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondo Crypto da Fonte di Capitale</h2><p>I tipi di fondi tipici includono il fondo proprietario, il fondo del conto gestito, il fondo privato regolamentato e il fondo pubblico.</p>
<p>● Fondo proprietario: come suggerisce il nome, non raccoglie denaro da LP esterni. I tipi comuni includono il tesoro interno delle istituzioni o gli uffici di famiglia.</p>
<p>● Fondo conto gestito: un conto gestito si riferisce a un conto di trading di proprietà di un investitore ma gestito da qualcun altro come gestori di fondi. I conti gestiti sono comunemente forniti da individui ad alto reddito o istituzioni che forniscono finanziamenti a margine come shadow banking nei mercati tradizionali, a un gruppo di vari gestori di fondi.</p>
<p>● Fondi privati regolamentati: questi fondi sono regolamentati dalle autorità locali come SEC/MAS/SFC, raccolgono denaro da investitori professionali esterni e devono rispettare determinati standard come avere un’entità del fondo, un gestore di fondi autorizzato, un custode esterno del fondo e presentare report supportati da società amministrative/revisione esterne del fondo.</p>
<p>● I fondi pubblici sono definiti allo stesso modo di quelli presenti sul mercato azionario. La maggior parte dei fondi pubblici segue strategie passive e tiene traccia dei NAV basandosi sulla sottoscrizione e il rimborso tramite finestra aperta/chiusa. I fondi crittografici pubblici di solito depositano gli asset presso un custode terzo autorizzato, mentre gli investitori al dettaglio o istituzionali negoziano le quote del fondo sul mercato secondario. I market maker possono fornire liquidità ai fondi pubblici come agli exchange.</p>
<p>La ricca varietà nella categorizzazione dei fondi crittografici, sia dal punto di vista del capitale che dell’attivo, presenta diversi vantaggi e sfide nella gestione e gestione dei fondi, come il controllo del rischio, la valutazione dei fondi e il regolamento. Estese discussioni per ciascun tipo particolare di fondi verranno trattate in articoli successivi. Questo articolo funge da sinossi ad alto livello per le istituzioni finanziarie per dare uno sguardo agli investimenti crittografici, nonché per invitare gli attori del settore a risuonare condividendo i loro pensieri ed esperienze.</p>
<p><strong><em>Divulgazione: questo articolo proviene da 1Token, fornitore di tecnologia nativa cripto dal 2015.</em></strong><br><strong><em>1Token è un fornitore di software per istituzioni cripto-finanziarie, che offre una soluzione tecnologica completa. Per ulteriori informazioni su 1Token, si prega di visitare <a href="https://1token.tech/" rel="nofollow noopener noreferrer" target="_blank">https://1token.tech/</a></em></strong></p>
<p><strong>Riferimento</strong><br><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">1] I fondi criptati esplodono in un anno di boom contrassegnato dal primo U.S. [Bitcoin</a> ETF.<br><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">https://www.bloomberg.com/news/articles/2021-12-21/crypto-funds-explode-in-2021-led-by-proshares-</a><a href="https://www.bloomberg.com/news/articles/2021-12-21/crypto-funds-explode-in-2021-led-by-proshares-<a href=&quot;https://www.gate.io/trade/BTC_USDT&quot; target=&quot;_blank&quot;>Bitcoin</a>-strategy-etf-bito" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>-strategy-etf-bito</p>
<div class="blog-details-info"><br><div>Autori:<strong> Yixuan Huang</strong>, Direttore commerciale di 1Token; <strong>Phil Yang</strong>, Responsabile commerciale di 1Token<br><div class="info-tips"><em> Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>