Q3J5cHRvIEZvbmRzZW4gMTAxOiBHZXJlZ3VsZWVyZGUgRm9uZHNuYWxldmluZyBPcGVyYXRpZXM=

2023-02-10, 02:23

<p><img src="https://gimg2.gateimg.com/image/article/167599535411.png" alt=""></p>
<h2 id="h2-Case20study20van20gereguleerd20cryptofonds853647"><a name="Case study van gereguleerd crypto-fonds" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Case study van gereguleerd crypto-fonds</h2><p>In dit gedeelte zullen we twee representatieve glen van gereguleerde crypto fondsen presenteren: een Cayman hedge fonds en een gereguleerd openbaar fonds in de VS.</p>
<h3 id="h3-AnB20Investeringen896259"><a name="AnB Investeringen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AnB Investeringen</h3><p>AnB is een gereguleerde crypto SPC geregistreerd op de Kaaimaneilanden. Momenteel heeft de SPC twee lopende fondsen:</p>
<ol>
<li><p>Een multi-strategisch fonds dat al onze strategieën omvat en grotere rendementen genereert door hogere volatiliteit en grotere marktblootstelling aan te gaan.</p>
</li><li><p>Een delta-neutraal fonds dat alleen delta-neutrale strategieën bevat. Dit fonds genereert stabiele rendementen door minimale volatiliteit en marktexposure te behouden.</p>
</li></ol>
<p>De SPC beheert een totaal AUM van $50 miljoen, verdeeld over verschillende investeringen in cryptocurrencies en DeFi. In combinatie streeft de SPC ernaar om alpha te genereren uit de volatiliteit en marktonvolkomenheden van de cryptomarkt. Strategieën omvatten directionele algoritmische handel, arbitrage, yield farming, enz. Inschrijving en inwisseling zijn elke maand mogelijk met een minimum investering van $100k. De inkomsten van het fonds omvatten een jaarlijkse beheersvergoeding van 2,4% en een prestatievergoeding van 20% bij het bereiken van de hoogste waterstand. Kosten van het fonds omvatten kosten voor strategieontwikkeling, handel, risicobeheer, operatie, juridische en auditgerelateerde kosten en personele overhead.</p>
<h3 id="h3-ProShares471378"><a name="ProShares" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ProShares</h3><p>ProShares is een gereguleerd openbaar fonds dat in de VS is geregistreerd. Het beheert het BITO-fonds, de eerste gereguleerde ETF in de VS. Dit fonds houdt momenteel geen BTC-spot (momenteel niet toegestaan ​​in de VS), maar volgt indirect BTC-bewegingen door BTC-futures aan te houden. Net als traditionele openbare fondsen kunnen BITO-aandelen worden verhandeld op de secundaire markt. Bij de fondsactiviteiten van BITO huurt het bedrijf derde partijen in, waaronder externe fondsbeheerders, fondsadministratie-agenten, bewaarders, overdrachtsagenten en distributeurs. Gereguleerde openbare fondsen zijn in vergelijking met privéfondsen beschikbaar voor alle publieke investeerders en worden daarom geconfronteerd met strengere regelgeving, frequentere openbaarmakingsvereisten (bijv. dagelijks iNAV) en als gevolg daarvan hogere operationele overheadkosten.</p>
<h2 id="h2-Hoe20u20een20gereguleerd20cryptofonds20kunt20beheren279515"><a name="Hoe u een gereguleerd crypto-fonds kunt beheren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe u een gereguleerd crypto-fonds kunt beheren</h2><p>Over het algemeen verwijzen buy-side bedrijven naar de verschillende modellen van fondsen en vermogensbeheer. Twee belangrijke aspecten van het runnen van een crypto buy-side bedrijf kunnen worden onderverdeeld in a) portefeuillebeheer en b) operationeel en compliance management. In de meeste glen wordt portefeuillebeheer uitgevoerd door een team van beleggingsprofessionals die zich richten op het bepalen van de vermogensallocatie en de algehele strategie van het bedrijf. In sommige glen kunnen externe handelsteams worden uitbesteed om zich bezig te houden met een deel van de beleggingsbeslissingen. Operationeel en compliance management daarentegen wordt uitgevoerd door een gezamenlijke inspanning van zowel interne teams als externe dienstverleners zoals fondsbeheerders en accountants, enz.</p>
<p>Hieronder volgt een uiteenzetting van de belangrijkste werkstromen voor het runnen van een crypto buy-side bedrijf vanuit het perspectief van het interne team van de fondsen en externe dienstverleners van derden.</p>
<h3 id="h3-Interne20team749640"><a name="Interne team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interne team</h3><p>● Het verkrijgen van een licentie:</p>
<p>Afhankelijk van de locatie en lokale regelgeving kunnen de nalevingsdrempels variëren voor de uitgifte van vergunningen voor het exploiteren van fondsen. Sommige regio’s stellen zeer hoge nalevingsdrempels, bijvoorbeeldBijvoorbeeld in Hongkong moeten bedrijven een licentie aanvragen bij de SFC voor het beheer van virtuele activa en de distributie van fondsen voor het beheer en de distributie van crypto-activa. In offshore gebieden zoals de Kaaimaneilanden en BVI is de nalevingsdrempel voor licenties echter veel lager en worden ze daarom populair voor cryptofondsen. Licentieaanvragen worden meestal behandeld door professionele fondsbeheerders en advocatenkantoren.</p>
<p>● Bepalen van uw fondsverklaring</p>
<p>Zoals elk traditioneel fonds moet een cryptofondsregistratie, zoals vereist onder de regelgeving, een gedetailleerde verklaring verstrekken met inbegrip van beleggingsbereik, handelsstrategieën, frequentie van opening, beheerskosten en prestatiekosten en relevante derde partijen (bewaring, administratie…) enzovoort.</p>
<p>Fundraising</p>
<p>Reguliere cryptofondsen zijn over het algemeen in USD uitgedrukt (de NAV van het fonds wordt berekend in USD). Voor elk in USD luidend cryptofonds kunnen beleggers zich abonneren op het fonds met behulp van USD of stabiele munten zoals USDT/USDC. In andere glen kunnen cryptofondsen ook worden uitgedrukt in cryptocurrency met een goede liquiditeit, zoals BTC en ETH. Gewoonlijk wordt de boekhouding van cryptofondsen gedaan in één coupure, hetzij in USD of de in cryptocurrency luidende cryptocurrency. Voor FoF’s/MoM’s die via beheerde accounts in meerdere cryptofondsen beleggen, kan de portefeuille echter in gemengde coupures worden geboekt, bijvoorbeeld zowel USD als BTC. Voor gereguleerde fondsen worden de fondsen van externe LP’s beveiligd en bewaard door een externe bewaarder. In veel glen kunnen cryptobeurzen rechtstreeks bewaringsdiensten aanbieden. In de afgelopen jaren zijn er ook aparte professionele bewaarders ontstaan, speciaal voor DeFi-handelsdoeleinden).</p>
<p>● Dagelijkse Operaties Beheren</p>
<p>De dagelijkse activiteiten van een fonds omvatten, maar zijn niet beperkt tot: inschrijving en aflossing door beleggers (verschillende frequenties), handelsuitvoering, uitvoering van de strategie, risicobeheer van posities en zekerheden, berekening van inkomsten en uitgaven, nalevingsrapportage, enz.</p>
<ol>
<li><p>Beheer van beleggersinschrijvingen en terugkopen: belangrijkste werkstromen omvatten het registreren en berekenen van elke beleggersinschrijving, terugkoop en afwikkeling voor enkelvoudige of gemengde denominatiefondsen, evenals de bijbehorende aanpassing van de fonds NAV.</p>
</li><li><p>Handelsuitvoering: belangrijkste werkstromen omvatten het instellen van pre-trade risicodrempels, bepalen van handelsstrategieën en bijhouden van alle handelsactiviteiten. Voor de uitvoering van de handel kiezen instellingen vaak voor algoritmische handelsstrategieën zoals TWAP of VWAP, handelen via OTC, of ontwikkelen ze interne kwantitatieve modellen om de algehele kosten te minimaliseren en de werkelijke marktprijs weer te geven.kwantitatieve strategieën.</p>
</li><li><p>Risicobeheer: de belangrijkste werkstromen omvatten het bepalen van belangrijke risicometingen en het nauwlettend monitoren en herzien van elk ervan. Gangbare risicobeheermetingen omvatten NAV, drawdown, blootstelling, LTV/liquidatie-waarschuwingen, stresstest, VAR, enz. Verschillende handelsstrategieën leggen verschillende nadruk op specifieke risicoparameters. Zo vereist een actieve strategie nauwlettend toezicht op drawdowns, terwijl een risiconeutrale strategie vereist dat het fondsblootstelling rond 0 wordt gehouden. Voor de strategie met vast rendement voor leningen worden verhoudingen zoals LTV (Loan to Value) toegepast om de waarde van het onderpand tijdens prijsschommelingen te monitoren. Voor de strategie met vast rendement voor DeFi is het cruciaal om realtime contractinformatie te verkrijgen om de risico’s dienovereenkomstig te monitoren.</p>
</li><li><p>Berekening van inkomsten en uitgaven: belangrijkste werkzaamheden omvatten het berekenen van uitgaven (toekomstige, niet-toekomstige en geamortiseerde) en inkomsten voor investeerders en managers, waaronder maar niet beperkt tot dividenden en winstdeling, beheerskosten en prestatievergoedingen (per individuele grenswaarde). Deze inkomsten en uitgaven worden berekend en gerapporteerd aan investeerders door externe fondsadministrateurs, en het interne fondsoperatieteam is voornamelijk verantwoordelijk voor gegevensverificatie.</p>
</li><li><p>Compliance-rapportage: cryptofondsen moeten regelmatig fondsprestaties onthullen en risicorapporten indienen. Gangbare maatstaven zijn fondsvaluatie, NAV, terugtrekking, volatiliteit, enz. Bovendien moeten fondsen gedetailleerde operationele gegevens verstrekken, zoals accountstortingen en -opnames, transactie- en handelshistorie, enz. voor audittrail en verzoening.</p>
</li></ol>
<p>● Beëindiging van het fonds: belangrijkste werkstromen omvatten de definitieve afwikkeling van handels- en bewaarrekeningen, en de afwikkeling van zowel kapitaal als aandelen van investeerders.</p>
<h3 id="h3-Dienstverleners20van20derden20bijv20fondsadministratie20bewaarder20en20accountantskantoren705428"><a name="Dienstverleners van derden (bijv. fondsadministratie, bewaarder en accountantskantoren)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dienstverleners van derden (bijv. fondsadministratie, bewaarder en accountantskantoren)</h3><p>Bevestiging van de dienstverleningsomvang: doorgaans omvat de verleende diensten investeerdersbeheer, rekeningbeheer, fondsboekhouding, administratief nalevingsbeheer, kostencalculatie en auditondersteuning, enzovoort.</p>
<ol>
<li><p>Beleggersbeheer: belangrijkste werkstromen zijn het beheer van beleggers’ KYC, fondsinschrijving en -aflossing, en het beheer van beleggersaandelen.</p>
</li><li><p>Handelsafstemming: de belangrijkste werkstromen omvatten het bijhouden van balansmomentopnames, stortings- en opnamerecords, transactie- en overdrachtsrecords, en alle handelsrecords voor alle rekeningen onder verschillende fondsen, evenals het uitvoeren van handelsafstemming op account- en fondsniveau op dagelijkse/wekelijkse/maandelijkse basis.</p>
</li><li><p>Berekening van fondsgerelateerde kosten: belangrijkste werkstromen omvatten het berekenen van beheervergoeding, prestatievergoeding, operationele kosten, enz.</p>
</li><li><p>Rapportage: de belangrijkste werkstromen omvatten het voorbereiden van een fondsprestatierapport voor investeerders met informatie over de fonds-NAV, normaal gesproken op maandelijkse basis. Andere omvatten het voorbereiden en leveren van kwartaal-, halfjaarlijkse en jaarlijkse resultatenrekeningen, balansen en kasstromenw verklaringen.</p>
</li></ol>
<p>Naast het begrijpen van de belangrijkste werkstromen voor het interne team van fondsen en externe dienstverleners, is het ook belangrijk om de belangrijkste verantwoordelijkheden van verschillende interne en externe functies te begrijpen.</p>
<h3 id="h3-Belangrijkste20verantwoordelijkheden20voor20intern20team378772"><a name="Belangrijkste verantwoordelijkheden voor intern team" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste verantwoordelijkheden voor intern team</h3><p>Typisch bestaat het interne team van een crypto buy-side bedrijf uit rollen zoals portefeuillemanager, handelaar, risicobeheerder, operationeel en compliance officer. Op basis van uniforme gegevensbron- en gegevenspipelinecriteria (bijv. marktgegevens verkrijgen via API’s, instellen van regels voor risicoberekening), werkt het interne team samen onder zowel interne als externe regelgeving.</p>
<ol>
<li><p>Portefeuillebeheerder: de belangrijkste verantwoordelijkheden omvatten het bijhouden van multidimensionale gegevens en gegevensanalyse van het fonds. De reikwijdte van gegevensregistratie en -analyse omvat alle tegenpartijen die verband houden met het fonds, alle instrumenten (inclusief gecentraliseerde en gedecentraliseerde) individuele of gecombineerde posities, PnL, KPI, enz. Portefeuillebeheerders zijn ook verantwoordelijk voor het extern genereren van op maat gemaakte rapporten voor investeerders of intern voor de raad van bestuur, wat extra reiniging en transformatie van ruwe gegevens zou vereisen.</p>
</li><li><p>Handelaar: belangrijkste verantwoordelijkheden omvatten efficiënte en stabiele orderuitvoeringen en fondsoverdrachten. Het bereik hiervan omvat het bewaken van marktomstandigheden, handelsprocessen (bijv. uitvoering van TWAP-algoritme mandaat) en relevante risicometingen.</p>
</li><li><p>Risicobeheerder: hoofdverantwoordelijkheden omvatten het instellen van risicobeheersregels, monitoring en rapportage van risico’s in realtime. Het bereik hiervan omvat marktniveau, fondsniveau, rekeningniveau en instrumentniveau monitoring, waarschuwingscontroles en vastleggen van gegevens.</p>
</li></ol>
<p>4.Compliance-officier: belangrijkste verantwoordelijkheden omvatten informatieboekhouding en -openbaarmaking volgens interne en externe regelgeving. Het bereik hiervan omvat handelsgoedkeuring, rapportvoorbereiding, periodieke openbaarmaking, indiening van regulerende gegevens, enz.</p>
<ol>
<li>Operationeel medewerker: belangrijkste verantwoordelijkheden zijn gegevensintegratie en coördinatie tussen het interne team en externe dienstverleners (meestal met fondsbeheerders). Het omvat doorgaans fondsinschrijving en -inlossing, NAV-berekening, kostenbeheer, fondswaardering, reconciliatie, historische gegevensregistratie en gegevensanalyse.</li></ol>
<h3 id="h3-Belangrijkste20verantwoordelijkheden20voor20derden20serviceproviders247182"><a name="Belangrijkste verantwoordelijkheden voor derden serviceproviders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste verantwoordelijkheden voor derden serviceproviders</h3><p>Beheerders van fondsen: belangrijkste verantwoordelijkheden omvatten het verstrekken van een nauwkeurige en tijdige ((wekelijkse of zelfs dagelijkse) berekening van NAV. Net als traditionele fondsen kunnen crypto-fondsen verschillen zien in de opbouw van prestatievergoedingen op basis van factoren zoals investeerderscategorie, fondscategorie, investeringsbedrag, aanhoudingstijd, fondsprestaties, etc. Met een toenemend aantal investeerders of frequentie van inschrijvingen en terugbetalingen zou handmatige berekening van NAV uiterst arbeidsintensief en tijdrovend worden.IT-infrastructuur die gegevensverwerking en berekening standaardiseert en vergemakkelijkt, kan van cruciaal belang zijn om de efficiëntie te verbeteren en de kwaliteit en snelheid van de dienstverlening voor crypto-fondsbeheerders te differentiëren.</p>
<p>Auditors: belangrijkste verantwoordelijkheden zijn het verzoenen van de wijzigingen in de accountbalansen met een 100% overeenkomende nettobeweging van stortingen en opnames, overboekingen, financiering en handelsactiviteiten. Het is dus noodzakelijk dat auditors ondersteuning bieden bij de verzoening voor alle soorten crypto-activa (spot, derivaten, DeFi, enz.) en bekend zijn met alle ‘konijnenholen’ met betrekking tot gegevensverzameling. BijvoorbeeldBijvoorbeeld, in veel glen kunnen onvolledigheid of fouten in transactiegeschiedenis worden veroorzaakt doordat beurzen geen historische balansmomentopnames kunnen verstrekken, geen exacte instrumentenlijsten hebben om handelsgeschiedenis te genereren, of speciale kosten zoals maker-rebates apart houden. Een efficiënte oplossing voor dergelijke veelvoorkomende pijnpunten is het stroomlijnen van de afstemming met een IT-systeem, het regelmatig maken van balansmomentopnames, het verzamelen van alle gegevens over activabewegingen en het uitvoeren van automatische afstemming.</p>
<p>Bewaarders: belangrijkste verantwoordelijkheden zijn onder andere het goedkeuren van overdrachten die beperkt zijn tot geautoriseerde adressen en rekeningen. Voorafgaande controle (monitoring en waarschuwing) en goedkeuring zijn noodzakelijk om de veiligheid van de activa van investeerders te waarborgen.</p>
<h2 id="h2-Marktkansen20voor20serviceproviders20van20derden792230"><a name="Marktkansen voor serviceproviders van derden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktkansen voor serviceproviders van derden</h2><p>Uit de vele potentiële klanten van 1Token blijkt uit de feedback dat er een groeiende behoefte is aan specifieke rapportagediensten voor crypto:</p>
<p>● Hogere rapportagefrequentie: de meeste fondsbeheerders kunnen alleen NAV leveren via een handmatig proces, wat niet voldoet aan de behoeften van crypto-fondsen en investeerders in deze 7*24 volatiele markt. Om dagelijks/wekelijks te kunnen genereren, hebben fondsbeheerders/auditbedrijven een IT-systeem nodig voor operationele schaalbaarheid.</p>
<p>● Boekhoudkundige afstemming voor complexe handelsstrategie: quMierenhandel, vooral high-frequency trading, kan duizenden en tienduizenden spots en derivaatorders per dag genereren, wat een grote uitdaging vormt voor fondsbeheerders om ervoor te zorgen dat de juiste verzoening wordt uitgevoerd. Fondsbeheerders / accountantskantoren hebben een robuust IT-systeem nodig dat perfect inspeelt op deze complexiteit.</p>
<p>● Gediversifieerde crypto-activaklasse: cryptofondsen kunnen verschillende soorten activa bevatten, waaronder spots, derivaten, DeFi, leningen, enz. Om de volledigheid te maximaliseren, hebben beheerders van cryptofondsen en auditkantoren uitgebreide software voor portefeuillebeheer nodig die alle crypto-activa ondersteunt en snel evolueert.</p>
<p>● Gegevensbeveiliging: voor institutionele klanten is het cruciaal dat leveranciers (fondsbeheerders / accountantskantoren) voldoen aan gegevensbeveiliging en vertrouwelijkheid, die doorgaans worden gewaarborgd door 1) technische oplossingen zoals lokale implementatie ter plaatse en 2) procesaudits zoals SOC 2-certificering.</p>
<p><strong><em>Openbaarmaking: Dit artikel is afkomstig van 1Token, een aanbieder van crypto-native technologie sinds 2015.</em></strong><br><strong><em>1Token is een softwareaanbieder voor crypto-financiële instellingen en biedt een alles-in-één technologische oplossing. Voor meer informatie over 1Token kunt u terecht op <a href="https://1token.tech/" rel="nofollow noopener noreferrer" target="_blank">https://1token.tech/</a></em></strong></p>
<p><strong>Referentie</strong><br>【1】Onder de DeFi golf, hoe moeten vermogensbeheerinstellingen voorzichtig goud delven. <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 Formulier N-1A REGISTRATIEVERKLARING.<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】Verklaring betreffende het regelgevend kader voor beheermaatschappijen van virtuele activa-investeringsportefeuilles, fondsverdelers en exploitanten van handelsplatforms.<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>Auteur:<strong>Yixuan Huang</strong>, BD-directeur van 1Token; <strong>Phil Yang</strong>, Hoofd BD van 1Token<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen in g van inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>