T250aHVsbGluZyB2YW4gV2ViMyBWQzogT3ZlciBkZSBsZXZlbnNjeWNsdXMgdmFuIFdlYjMgVkMgKERlZWwgSUkp

<p><img src="https://gimg2.gateimg.com/image/1691386857746346265blog.png" alt=""><br>In de wereld van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Venture Capital evolueert het landschap snel met unieke kenmerken en investeringsbenaderingen. Zoals benadrukt in het vorige artikel (DEEL I), breiden traditionele durfkapitaalfondsen hun dekking van Web3-projecten uit, terwijl toegewijde Web3 VC-fondsen actief investeren in startende bedrijven die bouwen op blockchain-technologie. In DEEL II van deze serie zullen we dieper ingaan op de levenscyclus van Web3 VC-fondsen, waarbij we de verschillende fasen onderzoeken zoals financiering, investeringen, bedrijfsvoering en exits. Door de complexiteit van het levenscyclusbeheer van Web3 VC te begrijpen, kunnen we waardevolle inzichten krijgen in de interne werking van deze fondsen en de strategieën die ze gebruiken om het altijd veranderende landschap van het Web3-ecosysteem te navigeren.</p>
<p><a href="/price/bitgert-brise" rel="nofollow noopener noreferrer" target="_blank">brise crypto</a><br>De hele levenscyclus van een Web3 investeringsfonds bestaat voornamelijk uit 4 fasen: Fondsenwerving, Investeringen, Operaties, Uitstappen.</p>
<h2 id="h2-Inzameling20van20geld692495"><a name="Inzameling van geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inzameling van geld</h2><p>Er kunnen meerdere financieringskanalen zijn voor Web3-ondernemingen:<br>● Gereguleerde durfkapitaalfondsentiteit: Alleen geaccrediteerde investeerders<br>● Eigen vermogen: Intern kapitaal, werknemers van de beheerder en zijn dochterondernemingen als investeerders, werknemers als fictieve investeerders (daadwerkelijke investeerders zijn hun familieleden of vrienden), enz.</p>
<p><strong>Beleggersprofielbeheer, KYC, inschrijving en aflossingsbeheer</strong><br>Bij het aan boord gaan van investeerders moet het klantprofiel goed worden bewaard. Ondertussen zal een Know Your Clients (KYC) -proces met workflow ontoereikend zijn voor nalevingsdoeleinden. Het ideale proces moet bestaan uit de volgende 4 stappen: het verkrijgen van materialen van investeerders, interne beoordeling, goedkeuring en registratie.<br>Correcte boekhouding van inschrijvingen van investeerders aan het begin (de meeste durfkapitaalfondsen zijn gesloten fondsen), overgangen van aandelen tijdens de looptijd, terugkopen van investeerders in de afsluitingsfase zal essentieel zijn. Op deze manier kunnen durfkapitaalbedrijven het rendement voor elke investeerder duidelijk berekenen en rente dragen wanneer het naar de afsluitingsfase van een onderneming gaat.</p>
<p><strong>Regelmatige rapportage aan investeerders</strong><br>Regelmatige rapportage aan geaccrediteerde beleggers is cruciaal. Het is niet alleen om te voldoen aan de nalevingsvereisten, maar ook om transparantie en vertrouwen op te bouwen tussen fondsbeheerders en beleggers.</p>
<p>Normaal gesproken zou een investeerdersrapport de volgende sectoren moeten bevatten:<br>● Fondsoverzicht: fondsgrootte, ingezet kapitaal, aantal investeringen, gerealiseerde opbrengsten, belangrijke indicatoren (IRR, MOIC, enz.)…<br>● Prestaties: grafieken en diagrammen die de prestatietrend aantonen<br>● Portefeuilleoverzicht: een lijst met volledige portefeuilles met belangrijke indicatoren van investeringen<br>● Belangrijke updates: updates die managers graag verstrekken met betrekking tot het fonds of de portefeuille.</p>
<h2 id="h2-Investering345992"><a name="Investering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investering</h2><p>Er zijn 3 lagen in risicokapitaalinvesteringen die goed beheerd en gecorreleerd moeten worden: Fonds/Eigen fonds, Portefeuilles en Onderliggende activa.</p>
<p><strong>Boekhouding van fondsen / eigen vermogen</strong><br>Gereguleerde fondsen kunnen een complexe structuur hebben (feeder fonds- master fonds- fondsen) en kunnen meerdere klassen aanbieden. Eigen vermogensfondsen kunnen ook worden toegewezen aan verschillende portefeuilles door meerdere portefeuillebeheerders. Er kunnen dus verschillende zakelijke scenario’s zijn die onder de boekhouding moeten vallen, voor nalevings- en fondsboekhoudingsdoeleinden. Daarom moet een beheerinstrument voldoende flexibiliteit bieden om verschillende zakelijke scenario’s te ondersteunen.</p>
<p><strong>Opnemen van portefeuilles investeringsinformatie</strong><br>Zoals vermeld, investeert Web3 ventures in veel portefeuilles. Het is dus belangrijk om een goed overzicht te hebben van de investeringsinformatie van al deze portefeuilles:<br>● Investeringsinformatie: investeringsdatum, bedrag en valuta, pre-trade en post-trade waardering, aandelenbezit…<br>● Belangrijke voorwaarden van de overeenkomst: details over SAFE/SAFT, anti-verwateringsclausule, exitclausules, voorkeursliquidatierechten, andere…<br>● Juridische en financiële bestanden: overeenkomsten, portefeuillepresentatie, whitepaper, andere juridische documenten…</p>
<p><strong>Volgen van onderliggende activa</strong><br>De onderliggende activa van de portefeuilles zijn aandelen/SAFE, tokens/SAFT of een mix van beide. Het is essentieel om ze op de juiste manier te boeken in de investeringsfase, vooral de initiële waardering ervan:<br>● Voor aandelen/SAFE/SAFT: De initiële investering (de kosten) wordt altijd beschouwd als de intrinsieke waarde van de tokens voordat de token genoteerd wordt.<br>● Voor liquide tokens: Normaal gesproken gebaseerd op de real-time prijs van gecentraliseerde/decentrale platformen. Het kan verschillen per VC-firma welke prijsbron wordt gebruikt als waarderingsbron. Maar over het algemeen gebruikt de meerderheid de prijs van CMC, of de mediane prijs van belangrijke gecentraliseerde beurzen (CEX) als de Fair Market Value (FMV).</p>
<h2 id="h2-Operaties717839"><a name="Operaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Operaties</h2><p><strong>Fondsboekhouding voor fondsen/eigen fondsen</strong><br>Net als alle grote fondshuizen die zich richten op secundaire markthandel, moet het interne operationele team van durfkapitalisten ook fondsboekhouding uitvoeren, zodat ze deze kunnen vergelijken met de rapporten van de fondsbeheerder. Middelste functionarissen moeten op de volgende punten letten om de juiste NAV, beheervergoeding, waterfall carried interests, enz. te krijgen:<br>● Fondsstructuur met meerdere lagen<br>● Inschrijving en terugkoop<br>● Vergoedingenboekingen en geamortiseerd<br>● Regelmatige herwaardering van aandelen/ SAFE en tokens/ SAFT (Zie ‘Herwaardering van onderliggende activa’)<br>● Verschillende fondsaandelen, die leiden tot verschillende investeerdersbases, minimale inschrijvingen, beheervergoedingen en carried interests…<br>● Aansprakelijkheid/ Leningsregistratie voor het scenario waarin werknemers fictieve investeerders zijn, terwijl de daadwerkelijke investeerders hun familieleden of vrienden zijn<br>● Anderen</p>
<p><strong>Waardering van activa</strong><br>Web3 VC-bedrijven moeten de waardering van de portefeuilles (aandelen/SAFE en tokens/SAFT) regelmatig monitoren en aanpassen tijdens de dagelijkse activiteiten, omdat<br>● De cryptomarkt erg volatiel is.<br>● Er is een grote afwijking tussen de marktprijs van tokens en de intrinsieke waarde wanneer ze net naar buiten komen.</p>
<ol>
<li>Het uitvoeren van haarstijlen helpt om de intrinsieke waarde van de tokens beter weer te geven in dergelijke situaties. Ondertussen zal het instellen van een premie ook helpen bij het ueren van de tokenwaarde wanneer er goed nieuws is binnen het ecosysteem/projecten.</li></ol>
<p>Na de ‘FTX Collapse’ op 8 november 2022 hebben Sequoia, Paradigm, Softbank en Temasek allemaal hun FTX-investeringen afgeboekt tot nul. Ondertussen hebben vermogensbeheerders die blootstelling hebben aan ‘FTT’ (FTX-utilitytoken) ook grote afschrijvingen uitgevoerd of de waarde van de token op nul gezet.</p>
<p><strong>Token vesting en ontgrendelingsschema</strong><br>Tokenomics in het whitepaper bepaalt het schema voor het vrijgeven van tokens en de ontgrendelingsregelingen.</p>
<p>De vestingsschema’s van portefeuilles verschillen. De meeste tokens worden niet-lineair verdeeld met kliffen (wat betekent dat investeerders tokens op specifieke data ontvangen, in plaats van geleidelijk een deel ervan te ontvangen), terwijl sommige tokens lineair worden verdeeld.</p>
<p><strong>AXS-toewijzingen en ontgrendelingsschema</strong><img src="https://gimg2.gateimg.com/image/16913870446245864281token.png" alt=""><br>Voor het ontgrendelen van tokens zijn er over het algemeen 3 gebruikelijke manieren:<br>● Tokens worden alleen gedistribueerd op de afgesproken ontgrendelingsdata van de tokens.<br>● Tokens worden gedistribueerd op Dag 1, maar vergrendeld door smart contracts.<br>● Tokens worden gedistribueerd en ontgrendeld op Dag 1, maar beide partijen zijn overeengekomen om niet te verkopen tot een bepaalde datum.</p>
<p>Het kan overweldigend zijn voor operationele managers om kasstromen en portefeuillemanagers te verzoenen om alle token-ontgrendelingsschema’s te onthouden, als het gaat om 100+ portefeuilles. Een beheerstool met de volgende functies kan de efficiëntie in hun dagelijkse werk helpen verhogen.<br>● Toekomstige kasstroomvoorspelling (tokenvorderingen)<br>● Automatisch verzoenen of kasstroom overeenkomt met tokenvorderingen<br>&amp; <a href="/how-to-buy/gatetoken-gt" rel="nofollow noopener noreferrer" target="_blank">Koop GateToken</a><br>● Herinneringen voor ontgrendeling van tokens</p>
<p>In sommige speciale glen kunnen portefeuilles onderhandelen om de data van de tokenverdeling te wijzigen. Daarom het vestingsschema en toekomstige cash <a href="/price/flow-flow" target="_blank" class="blog_inner_link">Flow</a> moet ook gemakkelijk kunnen worden aangepast.</p>
<p><strong>Opbrengstgeneratie (verder)</strong><br>Web3-projecten proberen tokenhouders meestal te laten vasthouden door het inzetten in liquiditeitspools te stimuleren. Als een passieve rendementsgeneratie kunnen VC-bedrijven deelnemen op basis van hun oordeel over de markt. In dergelijke scenario’s moet de portefeuillebeheerder de prestaties begrijpen, opgesplitst in 2 bronnen: investeringen op de primaire markt en handel op de secundaire markt, terwijl het operationele team de cashstroom moet begrijpenw splitsen tussen ontvangsten uit toekomstige aandelen en inkomsten uit investeringen.</p>
<p><strong>Interne analyse en rapportage</strong><br>Interne analyseverslagen zullen vergeleken met investeerdersverslagen relatief gedetailleerder zijn. Naast belangrijke indicatoren (AUM, MOIC, IRR, investeringen, opbrengsten, FMV, enz.), zullen interne analyseverslagen ook investeerders terugverdientijd analyse, enz. omvatten.</p>
<p><a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax prijs</a><br>We hebben het gehad over exit-strategieën in Web3-venturedeals. Specifiek, hoe en waar VC-bedrijven de tokens zullen verkopen bij exits?</p>
<p><strong>Waar af te sluiten</strong><br>● CeFi: beurs of OTC. Als de token genoteerd staat op CEX, is er een manier om te verkopen op de centrale limietorderboek. Er zijn verschillende OTC’s die RFQ of uitvoeringsservice bieden voor tokens.<br>● DeFi: Sommige nieuwe munten worden niet genoteerd op CEX, maar ze worden meestal gevonden in de toestemmingsloze DEXs zoals Uniruilen, Pancake Swap of Biswap, etc.</p>
<p><strong>Hoe afsluiten</strong><br>Als de tokens niet zijn genoteerd, maar vloeibaar zijn bij DeFi-protocollen, helpt ‘Swaping’ bij de exits.<br>Als de tokens zijn genoteerd op CEXs of DEXs, verkopen Web3-ondernemingen ze momenteel op 2 manieren:<br>● Voor ondernemingen met hun eigen handelsteam: Verkoop de tokens zelf met slimme TWAP-algo.<br>● Voor ondernemingen zonder handelsteam: Zoek market makers om de tokens voor hen te verkopen en de market makers zullen ofwel een prijs aanbieden met korting, of een uitvoeringsservice in rekening brengen van 0,5-1,5% van de totale uitgevoerde waarde.</p>
<p>Op welke manier dan ook, handelaren handelen altijd met een algoritme om de orders te splitsen in plaats van alle tokens in één keer te verkopen om grote marktimpact te vermijden. Time Weighted Average Price (TWAP) en TWAP met willekeurige ordergroottes zullen kernalgoritmes zijn die worden gebruikt. En één enkel Order en ution Management  (OEMS) met verbinding met meerdere handelsplatforms zal handig zijn voor handelaren.</p>
<h1 id="h1-1Token20omvat20het20levenscyclusbeheer20van20Web320VC734637"><a name="1Token omvat het levenscyclusbeheer van Web3 VC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1Token omvat het levenscyclusbeheer van Web3 VC</h1><p>Met dekking van de hele bedrijfscyclus biedt 1Token een alles-in-één oplossing voor Web3-ondernemingen.</p>
<h2 id="h2-Financieringsfase805951"><a name="Financieringsfase" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Financieringsfase</h2><p>● Beheer van beleggersprofielen en KYC-werkstroom<br>● Beheer van inschrijvingen en terugnames<br>● Regelmatige rapportage aan beleggers</p>
<h2 id="h2-Investeringsfase641835"><a name="Investeringsfase" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeringsfase</h2><p>● Boekhoudfondsen/eigen fondsen (ondersteunen van fondsen met een complexe structuur, bijv. Feeder-master-fund, fondsen met verschillende aandelen, enz.)<br>● Vastleggen van beleggingsinformatie van portefeuilles (ter ondersteuning van zowel de portefeuilleweergave van het fonds als de portefeuilleweergave van de beleggingsbeheerder)<br>● Onderliggende activa volgen</p>
<h2 id="h2-Operation20Stage911814"><a name="Operation Stage" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Operation Stage</h2><p>● Fondsenadministratie voor zowel liquide fondsen als illiquide fondsen<br>● Herzieningsaanpassing voor onderliggende activa<br>● Token-vestingbericht en token-ontgrendelingswaarschuwingen<br>● Interne analyse rapporten</p>
<h2 id="h2-Uitgang121648"><a name="Uitgang" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitgang</h2><p>● Liquiditeitsanalyse voor tokenverkoop op meerdere locaties<br>● Bijhouden van gerealiseerde en niet-gerealiseerde winst<br>● Berekening van draagrente</p>
<p>1Token heeft API-integratie met 80+ gecentraliseerde tegenpartijen (mainstream beurzen, bewaarders, banken, enz.), 20+ blockchains en 100+ protocollen, en 1Token kan API-verbinding ondersteunen met meer tegenpartijen op basis van de behoeften van klanten.</p>
<hr>
<p>Opgericht door een crypto-native team met meer dan 7 jaar ervaring in crypto <a href="/price/quant-qnt" target="_blank" class="blog_inner_link">Quant</a> trading, 1Token biedt een van de beste financiële software van institutionele kwaliteit voor crypto-instellingen om portefeuilles, risico’s en boekhouding te beheren.</p>
<p>Ons team zou graag potentiële strategische investeerders willen ontmoeten die een diepgaande kennis hebben van financiële SaaS, en actief investeren in de crypto finance vertical.</p>
<p>Voor verdere gesprekken kunt u contact opnemen met onze hoofd van Capital Markets - Annie Li (<a  rel="nofollow noopener noreferrer"  href="mailto:annie.li@1tokentech.com">annie.li@1tokentech.com</a>).</p>
<p>Snelle feiten:<br>● Ondersteunt momenteel 40+ wereldwijde crypto-instellingen<br>● Topklantprofiel incl. 3⁄5top crypto-beurzen, Animoca, Ant Alpha, Alfa 1, LTP, Matrixport, Nickel Digital, Nexo, etc.<br>● $12M opgehaald bij Sumscope, Gate, Matrixport, Folius en K3 Ventures</p>
<div class="blog-details-info"><br><div>Auteur:<strong>1Token</strong><br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div class="info-tips"><em></em>Geen enkele inhoud hierin mag worden beschouwd als beleggingsadvies en vormt geen enkel aanbod of verzoek om een investeringsproduct of -project aan te bieden of aan te bevelen.<br><div class="info-tips"><em>De opname van enig product van derden, diensten, entiteiten of inhoud vormt geen goedkeuring, aanbeveling of affiliatie door Gate.io. Voer grondig onderzoek uit en zoek professioneel advies voordat u investeringsbeslissingen neemt.<br></em><div class="info-tips"><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<p></p><p></p></div><p></p><br></div></div></div></div></div>