Q3J5cHRvIEZ1bmRzIDEwMTogT3BlcmF6aW9uaSBkaSBjb25mb3JtaXTDoCByZWdvbGFtZW50YXRhIGRlbCBmb25kbw==

2023-02-10, 02:23

<p><img src="https://gimg2.gateimg.com/image/article/167599535411.png" alt=""></p>
<h2 id="h2-Studio20di20caso20sui20fondi20crittografici20regolamentati558609"><a name="Studio di caso sui fondi crittografici regolamentati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Studio di caso sui fondi crittografici regolamentati</h2><p>In questa sezione, presenteremo due casi rappresentativi di fondi crittografici regolamentati: un hedge fund delle Cayman e un fondo pubblico regolamentato degli Stati Uniti.</p>
<h3 id="h3-AnB20Investimenti766070"><a name="AnB Investimenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AnB Investimenti</h3><p>AnB è un SPC criptato regolamentato registrato nelle Isole Cayman. Attualmente, l’SPC ha due fondi in esecuzione:</p>
<ol>
<li><p>Un fondo multi-strategia che include tutte le strategie della società e genera rendimenti maggiori assumendo una maggiore volatilità e una maggiore esposizione al mercato</p>
</li><li><p>Un fondo delta-neutro che contiene solo strategie delta-neutre. Questo fondo genera rendimenti costanti mantenendo una volatilità e un’esposizione di mercato minime.</p>
</li></ol>
<p>Lo SPC gestisce un AUM totale di 50 milioni di dollari USA, con la suddivisione dell’allocazione tra vari investimenti in criptovalute e DeFi. In combinazione, lo SPC mira a ottenere alfa dalla volatilità del mercato crittografico e dalle inefficienze di mercato. Le strategie includono il trading algoritmico direzionale, l’arbitraggio, il farming del rendimento, ecc. La sottoscrizione e il rimborso sono disponibili ogni mese con un investimento minimo di 100.000 dollari. Le entrate del fondo includono una commissione di gestione annuale del 2,4% e una commissione di performance del 20% al raggiungimento dell’high watermark. Le spese del fondo includono i costi dello sviluppo della strategia, del trading, della gestione del rischio, dell’operazione, delle spese legali e di audit e del personale.</p>
<h3 id="h3-ProShares148901"><a name="ProShares" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ProShares</h3><p>ProShares è un fondo pubblico regolamentato registrato negli Stati Uniti. Gestisce il Fondo BITO, il primo ETF regolamentato negli Stati Uniti. Questo fondo non detiene direttamente BTC spot (attualmente non consentito negli Stati Uniti), ma segue indirettamente i movimenti del BTC detenendo futures BTC. Come i tradizionali fondi pubblici, le azioni BITO possono essere scambiate sul mercato secondario. Nell’operatività del fondo BITO, la società assume terze parti, tra cui l’amministratore esterno del fondo, l’agente di contabilità del fondo, il custode, l’agente di trasferimento e il distributore. Rispetto ai fondi privati, i fondi pubblici regolamentati sono disponibili a tutti gli investitori pubblici e, quindi, sono soggetti a regolamentazioni più rigorose, maggiori requisiti di divulgazione più frequenti (ad es. iNAV giornaliero) e, di conseguenza, costi operativi più elevati.</p>
<h2 id="h2-Come20gestire20un20fondo20crittografico20regolamentato89159"><a name="Come gestire un fondo crittografico regolamentato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come gestire un fondo crittografico regolamentato</h2><p>In generale, le società del buy-side si riferiscono ai vari modelli di fondi e gestioni patrimoniali. Due aspetti chiave nella gestione di qualsiasi società del buy-side crypto possono essere categorizzati in a) gestione del portafoglio e b) gestione operativa e della conformità. Nella maggior parte dei casi, la gestione del portafoglio è gestita da un team di professionisti dell’investimento che si concentrano sulla determinazione dell’allocazione degli asset e sulla strategia complessiva della società. In alcuni casi, team di trading esterni possono essere esternalizzati per occuparsi di parte delle decisioni di investimento. La gestione operativa e della conformità, d’altra parte, è gestita da uno sforzo collaborativo che coinvolge sia team interni che fornitori di servizi esterni come amministratori di fondi e revisori, ecc.</p>
<p>Di seguito è riportato uno scomposizione dei principali workstream per gestire una società di acquisto di criptovalute dal punto di vista del team interno dei fondi e dei fornitori di servizi terzi esterni.</p>
<h3 id="h3-Squadra20interna489465"><a name="Squadra interna" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Squadra interna</h3><p>● Ottenere una licenza:</p>
<p>A seconda della posizione e dei requisiti normativi locali, le soglie di conformità possono variare per il rilascio delle licenze operative dei fondi. Alcune regioni presentano una soglia di conformità molto alta – ad esempioAd esempio, a Hong Kong, le aziende devono richiedere alla SFC la licenza di gestione degli asset virtuali e la licenza di distribuzione dei fondi per la gestione e la distribuzione degli asset crittografici. Tuttavia, in aree offshore come le Isole Cayman e le Isole Vergini Britanniche, la soglia di conformità per la licenza è molto più bassa e diventano quindi scelte popolari per i fondi crittografici. Le richieste di licenza sono di solito gestite da amministratori professionali di fondi e studi legali.</p>
<p>Determinazione del tuo estratto conto dei fondi</p>
<p>Come qualsiasi fondo tradizionale, una registrazione di un fondo cripto, come richiesto dalle normative, deve fornire una dichiarazione dettagliata che includa l’ambito degli investimenti, le strategie di trading, la frequenza di apertura, le commissioni di gestione e le commissioni di performance e terze parti pertinenti (custodia, amministrazione…) ecc.</p>
<p>● Raccolta fondi</p>
<p>I fondi crittografici mainstream sono generalmente denominati in USD (il NAV del fondo è calcolato in USD). Per qualsiasi fondo crittografico denominato in USD, gli investitori possono sottoscrivere il fondo utilizzando USD o stable coin come USDT/USDC. In altri casi, i fondi crittografici possono essere denominati anche in criptovalute con buona liquidità, come BTC ed ETH. Di solito, la contabilità dei fondi crittografici viene effettuata in un’unica denominazione, sia in USD che nella criptovaluta denominata. Tuttavia, per i FoF/MoM che investono in più fondi crittografici tramite conti gestiti, il portafoglio può essere contabilizzato in denominazioni miste, ad esempio sia in USD che in BTC. Per i fondi regolamentati, i fondi esterni degli LP saranno protetti e custoditi da un custode terzo. In molti casi, gli scambi di criptovalute possono fornire direttamente servizi di custodia. Negli ultimi anni, sono emersi anche custodi professionali separati, soprattutto per scopi di trading DeFi).</p>
<p>Gestione delle operazioni quotidiane</p>
<p>Le operazioni quotidiane di un fondo includono, a titolo esemplificativo ma non esaustivo: sottoscrizione e rimborso da parte degli investitori (varie frequenze), esecuzione della strategia di trading, gestione del rischio di posizioni e garanzie, calcolo di entrate e spese, reporting di conformità, ecc.</p>
<ol>
<li><p>Gestione delle sottoscrizioni e dei rimborsi degli investitori: le principali attività comprendono la registrazione e il calcolo di ogni sottoscrizione, rimborso e liquidazione degli investitori per fondi a denominazione singola o mista, nonché l’aggiustamento corrispondente del NAV del fondo.</p>
</li><li><p>Esecuzione del trading: i principali flussi di lavoro includono il settaggio dei limiti di rischio pre-negoziazione, la determinazione delle strategie di trading e la registrazione di tutte le attività di trading. Per l’esecuzione del trade, al fine di minimizzare il costo complessivo e riflettere il vero prezzo di mercato, le istituzioni adottano spesso strategie di trading algoritmico come TWAP o VWAP, effettuano scambi tramite OTC o sviluppano in-house.strategie quantitative.</p>
</li><li><p>Gestione del rischio: i principali flussi di lavoro includono la determinazione delle metriche chiave di rischio e il monitoraggio e la revisione attenta di ciascuna di esse. Le metriche comuni di controllo del rischio includono NAV, drawdown, esposizione, allerte LTV/liquidazione, stress test, VAR, ecc. Diverse strategie di trading pongono l’accento su parametri di rischio specifici. Ad esempio, una strategia attiva richiede un monitoraggio attento dei drawdown, mentre una strategia neutrale al rischio richiede che l’esposizione del fondo sia mantenuta intorno allo 0. Per la strategia di rendimento fisso di prestito, vengono applicati rapporti come LTV (Loan to Value) per monitorare il valore del collaterale durante le fluttuazioni di prezzo. Per la strategia di rendimento fisso di DeFi, è fondamentale ottenere informazioni contrattuali in tempo reale per monitorare i rischi di conseguenza.</p>
</li><li><p>Calcolo di entrate e spese: i principali flussi di lavoro includono il calcolo delle spese (accruate, non accrue e ammortizzate) e delle entrate per investitori e gestori, compresi ma non limitati a dividendi e quote di profitto, commissioni di gestione e commissioni di performance (per singolo high-water mark). Queste entrate e spese vengono calcolate e segnalate agli investitori dai fornitori di servizi di fondi di terzi, e il team interno di gestione del fondo è principalmente responsabile della verifica dei dati.</p>
</li><li><p>Segnalazione di conformità: i fondi cripto sono tenuti a rivelare regolarmente le prestazioni del fondo e a presentare rapporti di rischio. Le metriche comuni includono la valutazione del fondo, NAV, drawdown, volatilità, ecc. Inoltre, i fondi sono tenuti a fornire dati operativi dettagliati come depositi e prelievi di conto, transazioni e cronologia degli scambi ecc. per la pista di audit e la conciliazione.</p>
</li></ol>
<p>● Chiusura del fondo: i principali flussi di lavoro includono il regolamento finale dei conti di trading e di custodia e la compensazione sia del capitale che delle quote degli investitori.</p>
<h3 id="h3-Fornitori20di20servizi20di20terze20parti20ad20esempio20amministrazione20dei20fondi20custodia20e20societ20di20revisione351056"><a name="Fornitori di servizi di terze parti (ad esempio, amministrazione dei fondi, custodia e società di revisione)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fornitori di servizi di terze parti (ad esempio, amministrazione dei fondi, custodia e società di revisione)</h3><p>Conferma dell’ambito di servizio: tipicamente, i servizi comuni forniti includono la gestione degli investitori, la gestione del conto, la contabilità del fondo, la gestione della conformità amministrativa, il calcolo delle commissioni e l’assistenza nella revisione, ecc.</p>
<ol>
<li><p>Gestione degli investitori: i principali flussi di lavoro includono la gestione del KYC degli investitori, l’iscrizione e il rimborso dei fondi e la gestione delle quote degli investitori.</p>
</li><li><p>Conciliazione commerciale: i principali flussi di lavoro includono il monitoraggio degli snapshot dei saldi, i record di deposito e prelievo, i record di transazione e trasferimento e tutti i record di trading per tutti gli account sotto vari fondi, nonché la conciliazione commerciale a livello di account e fondo su base giornaliera/settimanale/mensile.</p>
</li><li><p>Calcolo delle spese correlate al fondo: i principali flussi di lavoro includono il calcolo della tassa di gestione, della tassa di performance, delle spese operative, ecc.</p>
</li></ol>
<p>4.Reporting: i principali flussi di lavoro includono la preparazione del rapporto sulle performance del fondo per gli investitori con informazioni sul NAV del fondo, di norma su base mensile. Altri includono la preparazione e la consegna dei rendiconti di reddito trimestrali, semestrali e annuali, bilanci e flussi di cassaw affermazioni.</p>
<p>Oltre a comprendere i principali flussi di lavoro per il team interno dei fondi e i fornitori di servizi terzi esterni, è anche importante comprendere le principali responsabilità dei vari ruoli interni ed esterni.</p>
<h3 id="h3-Principali20responsabilit20per20il20team20interno119769"><a name="Principali responsabilità per il team interno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali responsabilità per il team interno</h3><p>Tipicamente, il team interno di una società buy-side di criptovalute è composto da ruoli come portfolio manager, trader, controllo del rischio, operazioni e responsabile della conformità. Sulla base dei criteri di fonte dati unificata e del flusso dati (ad es. ottenere i feed di mercato tramite API, impostare la regola di calcolo dei fattori di rischio), il team interno lavora insieme nel rispetto delle normative interne ed esterne.</p>
<ol>
<li><p>Portfolio manager: le principali responsabilità includono il monitoraggio dei dati multidimensionali e l’analisi dei dati del fondo. La portata del monitoraggio e dell’analisi dei dati copre tutte le controparti relative al fondo, tutti gli strumenti (inclusi quelli centralizzati e decentralizzati), posizioni individuali o combinate, PnL, KPI, e così via. I portfolio manager sono anche responsabili della generazione di rapporti personalizzati esternamente per gli investitori, o internamente per il consiglio di amministrazione, che richiederebbero una pulizia e una trasformazione aggiuntiva dei dati grezzi.</p>
</li><li><p>Trader: le principali responsabilità includono esecuzioni ordini efficienti e stabili e trasferimenti di fondi. L’ambito di questo include il monitoraggio delle condizioni di mercato, dei processi di trading (ad esempio, esecuzione del mandato algoritmico TWAP) e delle metriche di rischio pertinenti.</p>
</li><li><p>Risk Controller: le principali responsabilità includono l’impostazione di regole di controllo del rischio, il monitoraggio e la segnalazione del rischio in tempo reale. L’ambito di tali attività comprende il monitoraggio a livello di mercato, a livello di fondo, a livello di conto e a livello di strumento, il controllo degli allarmi e la registrazione delle informazioni.</p>
</li></ol>
<p>4.Ufficiale di conformità: le principali responsabilità includono la tenuta dei registri e la divulgazione delle informazioni secondo le normative interne ed esterne. Il campo di applicazione di tali responsabilità include l’approvazione delle negoziazioni, la preparazione dei rapporti, la divulgazione periodica, la presentazione dei dati normativi, ecc.</p>
<ol>
<li>Ufficiale operativo: le principali responsabilità includono l’integrazione dei dati e il coordinamento tra il team interno e i fornitori di servizi esterni (di solito con gli amministratori dei fondi). L’ambito di tali attività comprende l’iscrizione e il rimborso dei fondi, il calcolo del NAV, la gestione delle spese, la valutazione dei fondi, la riconciliazione, il monitoraggio dei dati storici e l’analisi dei dati.</li></ol>
<h3 id="h3-Principali20responsabilit20per20i20fornitori20di20servizi20di20terze20parti161562"><a name="Principali responsabilità per i fornitori di servizi di terze parti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principali responsabilità per i fornitori di servizi di terze parti</h3><p>Amministratori di fondi: le principali responsabilità includono la fornitura di un calcolo accurato e tempestivo ((settimanale o anche giornaliero) del NAV. Come i fondi tradizionali, i fondi crittografici possono vedere variazioni nell’accumulo di commissioni di performance, in base a fattori quali la categoria dell’investitore, la categoria del fondo, l’importo dell’investimento, il tempo di detenzione, la performance del fondo, ecc. Con l’aumento del numero di investitori o della frequenza delle sottoscrizioni e dei rimborsi, il calcolo manuale del NAV diventerebbe estremamente laborioso e dispendioso in termini di tempo. StrLe infrastrutture IT in rapida evoluzione che standardizzano e facilitano l’elaborazione e il calcolo dei dati possono essere fondamentali per migliorare l’efficienza e differenziare la qualità e la velocità della fornitura di servizi per gli amministratori di fondi crittografici.</p>
<p>Gli auditor: le principali responsabilità includono conciliare le variazioni dei saldi dei conti al 100% corrispondenti al movimento netto dei depositi e prelievi, trasferimenti, finanziamenti e attività di trading. Pertanto, è necessario che gli auditor supportino la conciliazione per tutti i tipi di criptoasset (spot, derivati, DeFi, ecc.) e siano familiari con tutti i ‘buchi nel terreno’ relativi alla raccolta dati. Ad esempioAd esempio, in molti casi, l’incompletezza o gli errori nella cronologia delle transazioni possono essere causati dalla mancata capacità degli scambi di fornire istantanee storiche del saldo, dalla mancanza di elenchi precisi degli strumenti per generare la cronologia delle negoziazioni o dalla tenuta separata di commissioni speciali come sconti per i creatori. Una soluzione efficiente a tali punti critici comuni consiste nel razionalizzare la conciliazione con un sistema informatico, effettuando regolari istantanee del saldo, raccogliendo tutti i dati sugli spostamenti degli asset e conducendo una conciliazione automatica.</p>
<p>I custodi: le principali responsabilità includono l’autorizzazione dei trasferimenti da limitare agli indirizzi e agli account autorizzati. Il controllo pre-trasferimento (monitoraggio e avviso) e l’approvazione sono necessari per garantire la sicurezza degli asset degli investitori.</p>
<h2 id="h2-Opportunit20di20mercato20per20i20fornitori20di20servizi20di20terze20parti352505"><a name="Opportunità di mercato per i fornitori di servizi di terze parti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opportunità di mercato per i fornitori di servizi di terze parti</h2><p>Tra i numerosi potenziali clienti di 1Token, i feedback mostrano che c’è una crescente necessità di servizi di reportistica specifici per le criptovalute:</p>
<p>● Frequenza di reporting più elevata: la maggior parte degli amministratori di fondi può fornire solo il NAV tramite processo manuale, il che non soddisfa i fondi crittografici e gli investitori in questo mercato volatile 7*24. Per poter generare giornalmente/settimanalmente, gli amministratori di fondi/aziende di revisione richiedono un sistema IT per la scalabilità operativa.</p>
<p>Conciliazione contabile per strategie di trading complesse: quIl trading di formiche, in particolare il trading ad alta frequenza, può generare migliaia e decine di migliaia di spot e ordini di derivati al giorno, causando una grande sfida per gli amministratori dei fondi per garantire un corretto output di riconciliazione. Gli amministratori di fondi/le società di revisione contabile hanno bisogno di un sistema IT robusto che affronti perfettamente tale complessità.</p>
<p>● Classe di asset crittografici diversificata: i fondi crittografici possono contenere vari tipi di asset, inclusi spot, derivati, DeFi, prestiti, ecc. Per massimizzare la completezza, gli amministratori di fondi crittografici e le società di revisione hanno bisogno di un software completo di gestione del portafoglio che supporti ed evolva rapidamente con tutti gli asset crittografici.</p>
<p>● Sicurezza dei dati: per i clienti istituzionali, è cruciale che i fornitori (amministratori di fondi/società di revisione contabile) rispettino la sicurezza e la riservatezza dei dati, che sono comunemente garantite da 1) soluzioni tecniche come l’implementazione locale in loco e 2) audit dei processi come la certificazione SOC 2.</p>
<p><strong><em>Divulgazione: Questo articolo proviene da 1Token, fornitore di tecnologie native di criptovaluta dal 2015.</em></strong><br><strong><em>1Token è un fornitore di software per istituzioni cripto-finanziarie, che offre una soluzione tecnologica completa. Per maggiori informazioni su 1Token, visita il sito. <a href="https://1token.tech/" rel="nofollow noopener noreferrer" target="_blank">https://1token.tech/</a></em></strong></p>
<p><strong>Riferimento</strong><br>【1】In the wave of DeFi, how should asset management institutions prudently mine gold. <a href="https://note.youdao.com/ynoteshare/index.html?id=2b77cf9f844d66926abefc6ab93de111&amp;type=note&amp;_time=1650172263879" rel="nofollow noopener noreferrer" target="_blank">https://note.youdao.com/ynoteshare/index.html?id=2b77cf9f844d66926abefc6ab93de111&amp;type=note&amp;_time=1650172263879</a><br>【2】ProShares Trust Form N-1A REGISTRAZIONE STATOMENTO.<br><a href="https://www.sec.gov/Archives/edgar/data/0001174610/000168386321006052/f10028d1.htm#xx_da9783d3-0834-486d-895a-bf5a204a274f_1" rel="nofollow noopener noreferrer" target="_blank">https://www.sec.gov/Archives/edgar/data/0001174610/000168386321006052/f10028d1.htm#xx_da9783d3-0834-486d-895a-bf5a204a274f_1</a><br>【3】Dichiarazione sul quadro normativo per le società di gestione di portafogli di investimento in criptovalute, distributori di fondi e operatori di piattaforme di trading.<br><a href="https://www.sfc.hk/TC/News-and-announcements/Policy-statements-and-announcements/Statement-on-regulatory-framework-for-virtual-asset-portfolios-managers" rel="nofollow noopener noreferrer" target="_blank">https://www.sfc.hk/TC/News-and-announcements/Policy-statements-and-announcements/Statement-on-regulatory-framework-for-virtual-asset-portfolios-managers</a></p>
<div class="blog-details-info"><br><div>Autore:<strong>Yixuan Huang</strong>, Direttore BD di 1Token; <strong>Phil Yang</strong>, Responsabile delle relazioni aziendali di 1Token<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcuna suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio 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>