U3ZlbGFuZG8gV2ViMyBWQzogVmlhZ2dpbyBlIFN0cmF0ZWdpZSBkaSBJbnZlc3RpbWVudG8gKFBhcnRlIEkp

2023-08-01, 03:18

<p><img src="https://gimg2.gateimg.com/image/1690859957346804791blog.png" alt=""><br>.</p>
<h2 id="h2-Cos20il20Venture20Capital20di20Web3437136"><a name="Cos’è il Venture Capital di Web3?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il Venture Capital di Web3?</h2><p>Il venture capital è stato l’acceleratore di business per le start-up ad alto potenziale, finanziando queste aziende in una fase precoce con una bassa valutazione e beneficiando della crescita delle società in portafoglio. Nello spazio Web3, ci sono numerose squadre di start-up e una chiara via di uscita attraverso l’emissione di token, entrambe perfette per il business del VC.</p>
<p>Oltre al tradizionale VC / PE che copre tutti i settori e con una copertura parziale dei progetti <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> come Sequoia, ci sono venture capital dedicati a Web3 (Web3 VC) come a16z, Pantera, FBG Capital che finanziano attivamente le startup in fase iniziale che sviluppano tecnologia su blockchain o attività basate su asset digitali basati su blockchain.</p>
<p>Nel 2022, ci sono stati 1.477 affari con un investimento totale di 34,33 miliardi di dollari nei primi tre trimestri [2]. Anche se le tragedie di Luna e 3AC hanno raffreddato l’entusiasmo degli investitori e hanno indicato una diminuzione dell’afflusso di capitale di rischio nel terzo trimestre e il crollo di FTX potrebbe addirittura deteriorare la situazione nel quarto trimestre, vedremo comunque un trend al rialzo a lungo termine per i dati di mercato annuali alla fine di quest’anno.</p>
<p><strong>Affari di venture capital e acquisizione Web3 del 2022 nel Q1-Q3</strong><img src="https://gimg2.gateimg.com/image/16908609979356492408011.png" alt=""><br><strong>Fonte: ‘Venture Capital Research 2022 Q3 Overview’ di Cointelergaph e KeyChain Ventures</strong></p>
<p>Oltre agli investimenti nel mercato primario, le società di venture capital Web3 potrebbero anche investire in token liquidi e operare nel mercato secondario, quindi il bilancio è composto da attività onnicomprensive (ad es. azioni, token nativi, token liquidi, ecc.), in vari luoghi (ad es. diversi scambi centralizzati, custodi, banche, blockchain e protocolli, ecc.)</p>
<p>1Token, come società tecnologica nativa di cripto e veterana del mercato finanziario tradizionale, condividerà le sue conoscenze sui VC di Web3 e le sfide nella gestione del ciclo di vita.</p>
<h2 id="h2-Tipi20di20societ20di20venture20capital20Web3625188"><a name="Tipi di società di venture capital Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tipi di società di venture capital Web3</h2><p>I giocatori in Web3 VC possono essere categorizzati in 2 tipi: venture tradizionali con copertura parziale nello spazio Web3 e venture crypto-native.<br>Le venture tradizionali portano il fondo tradizionale (di solito grande) a Web3 e mostrano la seguente tendenza<br>● Affari concentrati (grande dimensione del biglietto, piccolo numero di portafogli)<br>● Processo decisionale lungo e dovuta diligenza accurata</p>
<p>Quindi il loro investimento è di solito interpretato come un forte riconoscimento per un team/progetto. D’altra parte, i giocatori nativi delle criptovalute possono essere più complessi. Ci sono principalmente 3 tipi: società di investimento primarie (ad es. a16z, Pantera, ecc.), market maker (società di trading), il braccio VC dell’exchange (ad es. Gate Venture, Coinbase Ventures, ecc.). Ognuno di loro ha il proprio vantaggio.<br><img src="https://gimg2.gateimg.com/image/169086099736111047208012.png" alt=""><br>.</p>
<h2 id="h2-Caratteristiche20degli20investimenti20di20Web320VC639107"><a name="Caratteristiche degli investimenti di Web3 VC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caratteristiche degli investimenti di Web3 VC</h2><p>Rispetto alle classiche operazioni di venture capital, gli investimenti in Web3 hanno le proprie caratteristiche.</p>
<p>●<br><strong>Sia il mercato primario che il mercato secondario</strong></p>
<p>La partecipazione delle società di venture capital Web3 al mercato secondario le distingue dai venture capital tradizionali. Le società di venture capital Web3 di solito mantengono i propri fondi liquidi o un portafoglio di token liquidi. Questo potrebbe essere sia per acquisire token sottovalutati dal mercato secondario, diversificando ulteriormente i loro portafogli di investimento, sia nei momenti in cui il mercato primario non offre buoni obiettivi, queste società di venture capital Web3 possono guadagnare rendimenti dal mercato secondario. Quindi le strategie di acquisto e detenzione e di rendimento sono oggi le allocazioni standard delle società di venture capital Web3, dove i venture capital Web3 agiscono come un misto tra i venture capital e i fondi speculativi nel mercato tradizionale.</p>
<p>●<br><strong>Approcci di investimento più diversificati</strong></p>
<p>Le imprese tradizionali investono principalmente nell’equity dell’azienda, mentre le imprese Web3 mirano principalmente ai token.<br>Le società di venture capital Web3 potrebbero investire in una combinazione di Simple Agreement of Future Equity (SAFE), Simple Agreement of Future Tokens (SAFT) e token liquidi. Tra tutti gli investimenti, SAFT è il più popolare per la sua comodità di incassare.</p>
<p>●<br><strong>Fattori unici da considerare negli investimenti???</strong></p>
<p>Oltre alla redditività a breve termine dei progetti, alla visione a lungo termine, all’esperienza del team, ai prodotti, ai mercati, all’ecosistema e così via, ci sono fattori unici negli scenari di investimento in token/SAFT che devono essere considerati. ‘Tokenomics’ ad esempio, è l’economia di un token, che include tutto, dall’offerta di token, all’emissione e all’utilità del token, ecc. Con gli stessi investimenti, i token distribuiti totali e il valore del token, diversi piani di vesting e disposizioni per lo sblocco del token elencati nella ‘Tokenomics’ possono portare a IRR completamente diversi.</p>
<p>Prendiamo un esempio<br>● Stesso investimento: Un Web3 VC ha investito sia nel portafoglio A che nel portafoglio B con gli stessi investimenti di 1 milione di USD.<br>● Lo stesso totale di token distribuiti: Il portafoglio A e B distribuiranno in totale 1 milione di token A e B.<br>● Stesso valore del token: Il Token A e B avranno lo stesso prezzo durante il periodo di vesting.<br>● Diverse scadenze di vesting e sblocco: Il 50% del token A è liquido nell’anno 1, il 30% nell’anno 2 e il 20% nell’anno 3. Mentre il 40% del token B è liquido nell’anno 1, il 30% nell’anno 2 e il 30% nell’anno 3.<br>● IRR diversi: L’IRR del portafoglio A si rivela essere del 71% e l’IRR del portafoglio B è solo del 47%.<br><img src="https://gimg2.gateimg.com/image/169086099794854852208013.png" alt=""><br>●<br><strong>Ciclo più breve e uscite più veloci</strong><br>Negli scenari di investimento in equità/SAFE, le strategie di uscita sono tradizionali, come Initial Public Offering (IPO), Fusione ed Acquisizione (M&amp;A), Management Buy-Outs (MBO)… Una di queste uscite richiede un lungo processo, poiché deve passare attraverso diverse revisioni e persino l’approvazione dei regolatori.</p>
<p>Nel contesto degli investimenti in token/SAFT, i cicli tra gli investimenti e le uscite sono molto più brevi. Le strategie di uscita in questi casi possono essere Initial Exchange Offering (IEO), Initial Decentralized Exchange Offering (IDO), Security Token Offering (STO) e scambi Over The Counter (OTC) con la gestione/altri giocatori.</p>
<p>A differenza dell’IPO, la quotazione dei token di IEO e IDO non è regolamentata (STO sta emergendo ma è ancora marginale). I token sono immediatamente liquidi una volta rilasciati (perché c’è il DEX). Per evitare che gli investitori escano immediatamente, i progetti di solito stabiliscono tokenomics e termini di vesting per mantenere la festa in corso.</p>
<p>Prendi gli investitori della vendita privata di AXS come esempio [3]:</p>
<ol>
<li>Gli investitori hanno investito $864,000 il 1 maggio 2020 ad un prezzo medio di $0,08.</li><li>Secondo la tokenomica di AXS nel suo whitepaper [4], il 20% dei token della vendita privata verrà sbloccato durante la vendita pubblica di AXS. Il resto dei token della vendita privata verrà sbloccato trimestralmente nei prossimi 2 anni.</li><li>L’IEO di AXS è avvenuto il 4 novembre 2020.</li></ol>
<p>Ciò significa che gli investitori delle vendite private avranno il 20% di token liquidi dopo 6 mesi (cliff), e il restante 80% verrà rilasciato in liquidità nei prossimi 2,5 anni.</p>
<p>●<br><strong>Grande quantità di affare e piccola dimensione del controllo</strong><br>Le imprese Web3 investono 10 volte o più nei portafogli rispetto alle imprese classiche e nel frattempo le aziende del progetto coinvolgono molti più investitori per ogni round. Le startup Web3 si stanno muovendo rapidamente nello sviluppo e nel fundraising, quindi i VC non possono fare una perfetta due diligence. Per massimo rendimento e minimo rischio, i VC Web3 devono coprire più progetti, piuttosto che essere cauti e perdere potenziali progetti stellari. Le grandi imprese investono facilmente in centinaia di aziende nel loro portafoglio (ad es. Coinbase ventures, Pantera, ecc.).</p>
<p>Le startup tendono anche a lavorare con più investitori. Come già detto, i fondatori si preoccupano del finanziamento, ma si aspettano anche di collaborare con gli investitori per aiutare a costruire e scalare il loro ecosistema.</p>
<p><strong>Riferimento:</strong><br>[1] ‘Panoramica della ricerca sul venture capital 2021’ di Cointelergaph e KeyChain Ventures:<br><a href="https://research.cointelegraph.com/reports/detail/venture-capital-report-2021-overview" rel="nofollow noopener noreferrer" target="_blank">https://research.cointelegraph.com/reports/detail/venture-capital-report-2021-overview</a><br>[2] ‘Panoramica sullo studio di Capitale di Rischio 2022 Q3’ di Cointelergaph e KeyChain Ventures:<br><a href="https://research.cointelegraph.com/reports/detail/venture-capital-report-q3-2022" rel="nofollow noopener noreferrer" target="_blank">https://research.cointelegraph.com/reports/detail/venture-capital-report-q3-2022</a><br>[3] <a href="/price/axie-infinity-axs" target="_blank" class="blog_inner_link">Axie Infinity</a> (AXTokenomica da CoinGecko:<br><a href="https://www.coingecko.com/en/coins/axie-infinity/tokenomics" rel="nofollow noopener noreferrer" target="_blank">https://www.coingecko.com/it/monete/axie-infinity/tokenomics</a><br>[4] Official Axie InWhitepaper di Finity:<br><a href="https://whitepaper.axieinfinity.com/axs/allocations-and-unlock/private-sale" rel="nofollow noopener noreferrer" target="_blank">https://whitepaper.axieinfinity.com/axs/allocations-and-unlock/private-sale</a></p>
<div class="blog-details-info"><br><div>Autore:<strong>1token.</strong><br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div class="info-tips"><em></em>Nessun contenuto qui costituirà consulenza in materia di investimenti e non costituisce alcuna offerta o sollecitazione di offerta o raccomandazione di alcun prodotto o progetto di investimento.<br><div class="info-tips"><em>L'inclusione di qualsiasi prodotto, servizio, entità o contenuto di terze parti non costituisce un'approvazione, raccomandazione o affiliazione da parte di Gate.io. Prima di prendere qualsiasi decisione di investimento, si prega di condurre una ricerca approfondita e consultare un professionista.<br></em><div class="info-tips"><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>