RGVTY2kgQ3J5cHRvOiBDb21lIGxhIEJsb2NrY2hhaW4gc3RhIFJpZGlzZWduYW5kbyBpbCBGdXR1cm8gZGVsbGEgUmljZXJjYSBTY2llbnRpZmljYT8=

2025-04-09, 10:21

<p><img src="https://gimg2.gateimg.com/image/article/1744193969desci.png" alt=""></p>
<p>Nell’onda del vigoroso sviluppo della criptovaluta e <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> tecnologia, un nuovo campo chiamato DeSci (Scienza Decentralizzata) sta silenziosamente emergendo. Cerca di affrontare i punti critici dell’allocazione ingiusta dei fondi, delle monopolie dei dati e della trasformazione inefficiente dei risultati nel tradizionale sistema di ricerca scientifica attraverso blockchain, smart contract e modelli economici basati su token. Questo articolo approfondirà la logica di base, gli scenari di applicazione e le sfide future della criptovaluta DeSci, svelando come questa traccia possa diventare un’intersezione rivoluzionaria tra la scienza e il mondo delle criptovalute.</p>
<h2 id="h2-DeSci20Crypto20Una20rivoluzione20paradigma20nella20ricerca20scientifica878275"><a name="DeSci Crypto: Una rivoluzione paradigma nella ricerca scientifica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeSci Crypto: Una rivoluzione paradigma nella ricerca scientifica</h2><p>Il tradizionale sistema di ricerca scientifica si trova da tempo di fronte a tre grandi dilemmi:</p>
<ol>
<li>Centralizzazione del finanziamento: governo e grandi imprese dominano l’allocazione dei fondi, rendendo difficile per settori di nicchia e ricercatori indipendenti ottenere supporto;</li><li>Data silo: i risultati della ricerca sono spesso privatizzati da riviste o istituzioni, rendendo costoso l’accesso pubblico;</li><li>Disallineamento degli incentivi: Gli scienziati investono anni di sforzi, ma a causa di problemi legati alla proprietà dei brevetti o alle barriere commerciali, trovano difficile ottenere un ritorno equo.</li></ol>
<p>DeSci Crypto ricostruisce l’ecosistema della ricerca attraverso la tecnologia blockchain:</p>
<ul>
<li>Finanziamento decentralizzato: le DAO (Organizzazioni Autonome Decentralizzate) consentono alla comunità globale di finanziare progetti di ricerca scientifica attraverso criptovalute, abbassando la soglia di finanziamento;</li><li>Condivisione di dati aperti: i risultati della ricerca vengono memorizzati sulla catena per ottenere tracciabilità permanente, resistenza alla manipolazione e confermati attraverso NFT.</li><li>Incentivi alla tokenizzazione: Gli scienziati possono attirare sostenitori precoci e condividere i profitti futuri emettendo token di ricerca (come BioCoin, DataToken).</li></ul>
<h2 id="h2-I20principali20scenari20di20applicazione20di20DeSci20Crypto470429"><a name="I principali scenari di applicazione di DeSci Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I principali scenari di applicazione di DeSci Crypto</h2><h3 id="h3-Ricerca20e20sviluppo20di20biotecnologie20dal20laboratorio20alla20comunit323582"><a name="Ricerca e sviluppo di biotecnologie: dal laboratorio alla comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricerca e sviluppo di biotecnologie: dal laboratorio alla comunità</h3><p>Caso: VitaDAO</p>
<ul>
<li>La prima organizzazione DeSci focalizzata sulla ricerca sulla longevità, che ha raccolto più di $4 milioni attraverso l’emissione di token VITA e ha finanziato più di 30 progetti anti-invecchiamento;</li><li>I risultati della ricerca (come i dati sulla terapia genica) vengono resi disponibili alla comunità sotto forma di NFT, consentendo agli investitori di partecipare alla governance e condividere i profitti dei brevetti con i token.</li></ul>
<h3 id="h3-Pubblicazione20scientifica20aperta20Rompere20il20monopolio20accademico707336"><a name="Pubblicazione scientifica aperta: Rompere il monopolio accademico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pubblicazione scientifica aperta: Rompere il monopolio accademico</h3><p>Caso: ResearchHub</p>
<ul>
<li>Gli scienziati caricano i documenti sulla piattaforma Blockchain e i lettori pagano una piccola commissione in criptovaluta (molto inferiore rispetto alle sottoscrizioni tradizionali delle riviste);</li><li>I revisori e i contributori ricevono le ricompense in token di piattaforma RSC, formando un meccanismo di incentivi di “contribuzione è mining”.</li></ul>
<h3 id="h3-Commercializzazione20della20Propriet20Intellettuale20PI608808"><a name="Commercializzazione della Proprietà Intellettuale (PI)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Commercializzazione della Proprietà Intellettuale (PI)</h3><p>Caso: Molecola</p>
<ul>
<li>I progetti biomedici rilasciano attivi di IP sulla catena, e gli investitori ottengono diritti brevettuali o quota di vendita acquistando NFT;</li><li>I contratti intelligenti allocano automaticamente i profitti, eliminando le commissioni degli intermediari.</li></ul>
<h2 id="h2-Larchitettura20tecnologica20sottostante20di20DeSci20Crypto427196"><a name="L’architettura tecnologica sottostante di DeSci Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’architettura tecnologica sottostante di DeSci Crypto</h2><ol>
<li>Layer di archiviazione: protocolli di archiviazione decentralizzati come IPFS e <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> garantire la disponibilità permanente dei dati della ricerca scientifica;</li><li>Strato di incentivi: Il modello economico dei token (come lo staking, il mining di liquidità) attira fondi e talento;</li><li>Strato di governance: il voto DAO determina l’allocazione dei fondi e la direzione del progetto, evitando la manipolazione istituzionale centralizzata;</li><li>Strato di conformità: la Prova a Zero Conoscenza (ZKP) protegge i dati della privacy garantendo nel contempo il rispetto dei requisiti normativi.</li></ol>
<h2 id="h2-Prospettive20future20DeSci907210"><a name="Prospettive future DeSci" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future DeSci</h2><p>Anche se DeSci Crypto ha un futuro promettente, deve superare i seguenti ostacoli:</p>
<ul>
<li>Incertezza normativa: i token di ricerca possono essere classificati come titoli, innescando rischi legali;</li><li>Controversia sulla qualità dei dati: la questione è ancora aperta su se la revisione della comunità aperta possa sostituire la revisione tra pari tradizionale;</li><li>Barriera tecnica: la maggior parte degli scienziati è ancora poco familiare con la criptovaluta e le operazioni DAO.</li></ul>
<p>Previsione delle tendenze future:</p>
<ul>
<li>2024-2025: Il progetto DeSci si concentrerà su aree ad alto rischio e alto rendimento come la biomedicina e le scienze climatiche;</li><li>Dopo il 2026: l’interoperabilità cross-chain migliora, formando un mercato globale per il commercio di dati di ricerca scientifica;</li><li>Visione a lungo termine: combinazione AI+DeSci, generazione automatica on-chain di ipotesi, esperimenti di verifica e allocazione delle risorse.</li></ul>
<p>DeSci Crypto non è solo un’innovazione negli strumenti tecnici, ma anche una rivoluzione nel modello di governo scientifico. Porta la ricerca dalla “torre d’avorio” alla comunità aperta, rendendo la creazione di conoscenza e la distribuzione del valore più equi ed efficienti. Nonostante le sfide in arrivo, con sempre più scienziati, sviluppatori e investitori che si uniscono, ci si aspetta che DeSci diventi la prossima scena delle applicazioni tecnologiche blockchain da mille miliardi di dollari dopo DeFi e GameFi.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Icing</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Gli investimenti comportano rischi e gli utenti devono prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il repost dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>