Q3J5cHRvIEZ1bmRzIDEwMTogQ2xhc3NpZmljYXRpZSB2YW4gZm9uZHNlbg==

<p><img src="https://gimg2.gateimg.com/image/article/167540508711.png" alt=""><br>Als ervaren veteraan in de cryptohandel en de ontwikkeling van front- en backoffice-infrastructuur heeft het 1Token-team een reeks artikelen voorbereid om ervaringen en inzichten te delen in het beheer van cryptofondsen. Dit artikel zal dienen als een openingsintroductie, waarin typische typen cryptofondsen in de steeds meer gereguleerde cryptomarkt van vandaag worden behandeld.</p>
<h2 id="h2-Prelude20Van20traditionele20fondsen20naar20cryptofondsen677495"><a name="Prelude: Van traditionele fondsen naar cryptofondsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prelude: Van traditionele fondsen naar cryptofondsen</h2><p>Over het algemeen is een fonds een pool van kapitaal toegewezen aan een specifiek doel.</p>
<p>Gemeenschappelijke bronnen van kapitaal zijn onder andere trusts, soevereine fondsen, verzekeringsmaatschappijen en verschillende soorten stichtingen. Investeringsbeslissingen worden echter genomen door fonds GPs, die professionele vermogensbeheerders zijn die als doel hebben hogere rendementen te genereren door fondskapitaal toe te wijzen aan zowel primaire (venture capital, private equity) als secundaire markten.</p>
<p>Crypto fondsen hebben zich al jaren ontwikkeld. Vanaf 2014, toen crypto fondsen voor het eerst opdoken, tot 2021, toen de eerste U.S. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Tegen Bitcoin</a> Met de lancering van ETF heeft een groeiend aantal hedgefondsen en family offices geïnvesteerd in crypto-activa. De bullmarkt in 2020-2021 heeft de totale marktkapitalisatie van cryptofondsen verder verhoogd tot meer dan $62 miljard. Vandaag de dag stappen steeds meer traditionele financiële instellingen (en zelfs niet-financiële instellingen) in de cryptocurrency-business door hun eerste toewijzing aan crypto-gerelateerde activa.<br><img src="https://gimg2.gateimg.com/image/article/167540525022.png" alt=""><br>Hoewel cryptofondsen vergelijkbaar zijn met traditionele fondsen qua fondsstructuur en basisportefeuilleclassificatie, maakt de gedecentraliseerde blockchain-infrastructuur cryptomiddelen anders dan traditionele financiële activa zoals aandelen en obligaties, en worden ze geconfronteerd met een grotere verscheidenheid en een groter aantal activatypen / instrumenten, handelsplatforms en strategieën, en meer geavanceerde IT-vereisten. Bovendien zijn er veel opmerkelijke nuances op het gebied van risicobeheer, berekening van fonds-KPI’s en fondsaudits.</p>
<p>Als ervaren veteraan in crypto-handel en front-to-back-office-infrastructuurontwikkeling heeft het team van 1Token een reeks artikelen voorbereid om ervaringen en inzichten te delen in het beheren van cryptofondsen. Dit artikel zal dienen als een openingsintroductie, waarin typische soorten cryptofondsen in de steeds meer gereguleerde cryptomarkt van vandaag worden behandeld.</p>
<p>Toekomstige artikelen zullen ingaan op de belangrijkste punten bij fondsbeheer en -activiteiten voor verschillende soorten fondsen, beheerders en derde partijen, evenals een diepgaande analyse van de kenmerken van elk.</p>
<h2 id="h2-Classificatie20van20Crypto20Fondsen452110"><a name="Classificatie van Crypto Fondsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Classificatie van Crypto Fondsen</h2><p>Crypto fondsen kunnen worden ingedeeld in primaire marktfondsen en secundaire marktfondsen.</p>
<p>Primaire marktfondsen (zoals VCs, Seed/Growth Funds, enz.) investeren voornamelijk in op blockchain gerelateerde projecten, waaronder pre-ITO (Initial Token Offering) projecten, post-ITO projecten die nog niet zijn genoteerd op de belangrijkste beurzen (Binance, FTX, Coinbase, enz.), evenals Non-Fungible Token (NFT) projecten.</p>
<p>Secundaire marktfondsen richten zich daarentegen op investeringen in cryptocurrencies en hun derivaten, die rechtstreeks op beurzen of over-the-counter (OTC) kunnen worden verhandeld. Naast classificaties door publieke / private, open-end / closed-end fondsen zoals traditionele fondsen, kunnen cryptofondsen worden ingedeeld op basis van beleggingsstrategie, handelsfrequentie en bron van kapitaal. Afhankelijk van het specifieke fondstype zijn verschillende niveaus van infrastructuur en IT-middelen vereist bij dagelijkse fondsoperaties.</p>
<h2 id="h2-Crypto20Fonds20Op20Basis20Van20Beleggingsstrategie525412"><a name="Crypto Fonds Op Basis Van Beleggingsstrategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Fonds Op Basis Van Beleggingsstrategie</h2><p>Typische strategieën omvatten Beta (passief), Neutraal/Alpha (hoogfrequent en delta neutraal), Actief (actief beheerd) en Opbrengst (vaste inkomsten).</p>
<p>● Passieve strategie: rendementen worden vergeleken met de algemene beweging van de cryptomarkt. Typische strategieën omvatten het bijhouden van de prestaties van één specifieke munt of een mandje van mainstream munten (BTC en ETH)</p>
<p>● Neutrale/Alpha-strategie: rendementen worden behaald uit marktvolatiliteit, waarbij derivatenafdekking wordt gebruikt om de lange termijn Delta op nul te houden. Typische neutrale strategieën omvatten arbitrage en marktmaken.</p>
<p>● Actieve strategieën worden bepaald door het subjectieve oordeel van managers over prijsbewegingen (bijvoorbeeld, long gaan wanneer de prijs laag is en short gaan wanneer de prijs hoog is). Posities worden aangepast op basis van het verschil tussen marktprijs en subjectieve prijs, wat resulteert in extra alpha ten opzichte van de beta return gegenereerd door marktbewegingen.</p>
<p>● Opbrengststrategie: Hoewel er momenteel geen standaard crypto-obligatiemarkt is, kan een opbrengstfonds investeren in ‘niet-standaard obligaties’ (zoals OTC-leningen en prime brokerage), die populaire modellen zijn die vaste rendementen genereren vergelijkbaar met obligaties door netto rente-inkomsten te genereren uit back-to-back leningen. Opbrengstfondsoperaties vereisen over het algemeen striktere risicobeheersing vanwege de drastische fluctuatie van crypto-gecollateraliseerde activa (zoals Luna en UST in mei 2022). Een andere veelvoorkomende strategie voor opbrengstfondsen is om deel te nemen aan DeFi-financiële activiteiten op basis van smart contracts op de blockchain die vastrentende eigenschappen hebben. Zo maakt yield farming op DeFi smart contracts (niet van toepassing in traditionele financiële markten) het mogelijk voor fondsbeheerders om munten uit te lenen, te lenen of te staken om rente te verdienen en te speculeren op prijsschommelingen.</p>
<h2 id="h2-Crypto20Fondsen20Op20Basis20Van20Handelsfrequentie101260"><a name="Crypto Fondsen Op Basis Van Handelsfrequentie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Fondsen Op Basis Van Handelsfrequentie</h2><p>Typische strategieën omvatten lage frequentie (handmatig handelen), middelmatige frequentie (semi-algo handelen) en hoge frequentie (kwantitatief handelen).</p>
<p>● Handmatig handelen: orders worden met de hand geplaatst op uitwisselingswebsites/apps/brokers, of via OTC, of via handelsterminals door IT-infrastructuurproviders.</p>
<p>● Semi-algo-handel: orders worden geplaatst door het totale orderbedrag met de hand in te stellen, en uitgevoerd door vooraf ingestelde programma’s (TWAP, VWAP, PEG, enz.).</p>
<p>● Kwantitatieve handel: bestellingen worden geplaatst door programma’s, die via API’s verbinding maken met beurzen.</p>
<p>Er zijn verschillende belangrijke verschillen tussen handelen op de cryptomarkt en de traditionele financiële markt:</p>
<ol>
<li><p>cryptocurrencies kunnen worden verhandeld 24⁄7</p>
</li><li><p>dezelfde muntparen (bijv. BTC/USD Spot) kunnen op meerdere plaatsen (beurzen/OTC’s) worden verhandeld. Er zijn in totaal honderden gecentraliseerde crypto-beurzen (Binance, FTX, Deribit, OKX etc.) en gedecentraliseerde crypto-beurzen (Uniswap en <a href="/price/pancakeswap-cake" target="_blank" class="blog_inner_link">Pancakeswap</a> etc.) wereldwijd</p>
</li><li><p>Crypto-fondsen kunnen rechtstreeks gratis marktoffertes ontvangen en orders plaatsen via beurzen (zelfs HFT’s), in plaats van te moeten handelen via makelaars.</p>
</li></ol>
<p>Deze drie onderscheidingen resulteren in meer arbitragemogelijkheden voor Alpha-strategieën op de cryptomarkt (bijv. arbitrage tussen beurzen). In typische glen zullen fondsbeheerders een verschillende handelsfrequentie hanteren op basis van hun rendementsdoelstelling, handelsstrategie en IT-capaciteit.</p>
<h2 id="h2-Crypto20Fonds20door20Bron20van20Kapitaal752317"><a name="Crypto Fonds door Bron van Kapitaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Fonds door Bron van Kapitaal</h2><p>Typische soorten fondsen zijn eigen fonds, beheerd accountfonds, gereguleerd privéfonds en openbaar fonds.</p>
<p>● Eigen vermogen: zoals de naam al aangeeft, wordt er geen geld opgehaald bij externe LP’s. Gangbare typen omvatten het interne schatkist van instellingen of family offices.</p>
<p>● Beheerd accountfonds: een beheerd account verwijst naar een handelsaccount dat eigendom is van een investeerder maar wordt beheerd door iemand anders zoals fondsbeheerders. Beheerde accounts worden doorgaans gegeven door vermogende particulieren of instellingen die marginfinanciering bieden zoals schaduwbankieren in traditionele markten, aan een groep verschillende fondsbeheerders.</p>
<p>● Gereguleerde private fondsen: deze fondsen worden gereguleerd door lokale autoriteiten zoals SEC/MAS/SFC, halen geld op bij externe professionele investeerders en moeten voldoen aan normen zoals het hebben van een fonds entiteit, een vergunde fondsbeheerder, een externe fondsbewaarder en het indienen van rapporten ondersteund door externe fondsadministratie/accountantskantoren.</p>
<p>● Publieke fondsen worden gedefinieerd als die op de aandelenmarkt. De meeste publieke fondsen volgen passieve strategieën en volgen NAV’s op basis van open/sluit venster inschrijving en terugkoop. Publieke cryptofondsen storten meestal activa bij een geautoriseerde derde partij bewaarder, terwijl particuliere of institutionele beleggers fondsaandelen verhandelen op de secundaire markt. Market makers kunnen liquiditeit verschaffen aan publieke fondsen zoals aan beurzen.</p>
<p>De rijke verscheidenheid aan crypto-fondscategorisatie, vanuit zowel kapitaal- als activaperspectieven, biedt verschillende voordelen en uitdagingen in fondsbeheer en -werking, zoals risicobeheersing, fondswaardering en afwikkeling. Uitgebreide discussies over elk specifiek type fondsen zullen worden behandeld in volgende artikelen. Dit artikel dient als een beknopt overzicht op hoog niveau voor financiële instellingen om een glimp op te vangen van crypto-investeringen, evenals om deelnemers in de sector uit te nodigen om hun gedachten en ervaringen te delen.</p>
<p><strong><em>Openbaarmaking: Dit artikel is afkomstig van 1Token, een inheemse cryptotechnologieaanbieder 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, bezoek alstublieft <a href="https://1token.tech/" rel="nofollow noopener noreferrer" target="_blank">https://1token.tech/</a></em></strong></p>
<p><strong>Referentie</strong><br><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">1] Crypto-fondsen exploderen in een boomjaar dat wordt gekenmerkt door de eerste 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>Auteurs: <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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>