RGVTY2krTWVtZSwgSXMgaGV0IG5vZyBlZW4gbmlldXdlIGNvbWJpbmF0aWV0eXBlIHBvdGVudGllZWwgbnVtbWVyPw==

2024-11-21, 08:29

<p><img src="https://gimg2.gateimg.com/image/article/17321773501690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR897995"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Het DeSci-veld, als een opkomend vakgebied dat kan worden gecombineerd met real-world toepassingen, heeft onlangs een groot aantal investeerders aangetrokken en kapitaalstromen, te beginnen met de investering in BIO Protocol.</p>
<p>De combinatie van DeSci en Meme is ook een nieuw onderwerp geworden, en de innovatieve projecten RIF en URO van het Pump.Science-platform hebben aanzienlijke markthype aangetrokken.</p>
<p>Sommige DeSci-projecten, zoals Sci Hub, hebben een zekere mate van innovatie en bruikbaarheid. Met de populariteit van Meme dragen ze bij aan het vergroten van het publieke belang en bewustzijn van DeSci.</p>
<h2 id="h2-Introductie310970"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Na AI Meme, mascotte Meme, kunstwerk Meme en redding van dieren Meme heeft het DeSci-veld ook recentelijk marktaandacht gekregen, te beginnen met grootschalige investeringen in gedecentraliseerde curatie- en liquiditeitsprotocol BIO Protocol, en er is een nieuwe golf van Meme-gekte stilletjes opgekomen.</p>
<p>Hoewel DeSci nog steeds weinig populair is in de industrie, heeft dit nieuwe concept door de toevoeging van Meme een nieuw niveau van populariteit bereikt. Dit artikel zal dit in detail onderzoeken.</p>
<h2 id="h2-DeSci20Molecule20DAO20en20PumpScience212373"><a name="DeSci, Molecule DAO en Pump.Science" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeSci, Molecule DAO en Pump.Science</h2><p>DeSci, ook wel bekend als ‘gedecentraliseerde wetenschap’, is een opkomend gebied van cryptocurrency dat tot doel heeft te benutten <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> technologieën (inclusief NFT’s, smart contracts en DAO’s) om eerlijke en rechtvaardige financiering, creatie, beoordeling, opslag en verspreiding van wetenschappelijke kennis te bevorderen. Deze innovatieve actie moedigt wetenschappers aan om hun onderzoeksresultaten openbaar te delen, waardoor het voor iedereen gemakkelijk is om toegang te krijgen tot en bij te dragen aan wetenschappelijke prestaties.</p>
<p>Hoewel DeSci nog steeds een nieuw concept is voor veel crypto beoefenaars en het niet erg populair is, hebben veel VC’s en KOL’s openlijk hun <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> over dit veld.</p>
<p>Volgens de statistieken van ThePASS van vorig jaar vertegenwoordigde DAO het grootste deel van de DeSci-gerelateerde organisaties, met bekende namen zoals ResearchHub, VitaDAO, MoonDAO, CrunchDAO, enz.<img src="https://gimg2.gateimg.com/image/article/17321775521.jpeg" alt=""><br>Bron: ThePASS</p>
<p>Het artikel introduceert voornamelijk de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Eco Molecule DAO, een actieve DeSci-organisatie opgericht in 2020. Het heeft niet alleen het concept voorgesteld om intellectueel eigendom te combineren met cryptocurrency door gebruik te maken van IP-NFT-technologie, waardoor het mogelijk is om het eigendom van wetenschappelijke onderzoeksprojecten te delen, maar lanceerde ook een Meme coin launchpad genaamd Pump.Science op de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Breakpoint-conferentie op Token 2049.<img src="https://gimg2.gateimg.com/image/article/17321775732.jpeg" alt=""><br>Bron: molecule.xyz</p>
<p>In tegenstelling tot andere Meme-coin platforms, is het kenmerk van Pump.Science de ondersteuning van medisch experimenteel onderzoek. Medisch onderzoekers kunnen voorstellen voor medicijnonderzoek indienen en wormexperimenten uitvoeren op het platform. Gebruikers kunnen deelnemen aan het experimentele proces door te handelen in Meme-tokens die medicijnen vertegenwoordigen, medicijneffecten voorspellen op basis van experimentele resultaten, en doorgaan met handelen in Meme-tokens.</p>
<p>Met andere woorden, Pump.Science kan worden gezien als een op tokens gebaseerd voorspellingsspel voor levensduurverlengingsexperimenten. Nadat Meme-tokens die medicijnen vertegenwoordigen zijn uitgegeven op Pump.fun, kunnen spelers rechtstreeks transacties uitvoeren. Wanneer de marktkapitalisatie $10.000 bereikt, zal het medisch onderzoeksorganisatie ORA Biomedical het medicijn gebruiken in experimenten en regelmatig de testresultaten publiceren op het Pump.Science-platform. Dit innovatieve model biedt niet alleen financiële ondersteuning voor medische experimenten, maar biedt gebruikers ook een interessante manier om deel te nemen aan wetenschappelijk onderzoek.<img src="https://gimg2.gateimg.com/image/article/17321775923.jpeg" alt=""><br>Bron: pump.science</p>
<p>Onlangs zijn de twee Meme-munten van Pump.Science snel populair geworden, waardoor de aandacht van de markt naar het DeSci-traject wordt getrokken.</p>
<h2 id="h2-Met20een20honderdvoudige20toename20in20een20week20worden20RIF20URO20en20SCIHUB20viraal881000"><a name="Met een honderdvoudige toename in een week, worden RIF, URO en SCIHUB viraal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met een honderdvoudige toename in een week, worden RIF, URO en SCIHUB viraal</h2><p>Deze week heeft DeSci veel aandacht gekregen met de steun van CZ, Vitalik en andere platforms. In het bijzonder hebben BIO ecosysteem DAO-tokens zoals VITA, ATH en RSC allemaal aanzienlijke stijgingen gezien, en zelfs in de context van verschillende Altcoin sectoren die worden leeggezogen, hebben deze tokens een sterke prestatie behouden.</p>
<p>Misschien geïnspireerd door AIMeme, is de combinatie van DeSci+Meme een nieuwe hotspot geworden. Hoewel de twee nieuwe munten, RIF en URO, van het Pump.science-platform in de beginfase van hun lancering niet veel aandacht trokken, met marktkapitalisaties die schommelden rond de $150.000, hebben deze twee tokens onlangs een explosieve groei doorgemaakt. In minder dan twee dagen zijn de marktkapitalisaties van RIF en URO gestegen naar respectievelijk $173 miljoen en $55,6 miljoen, een verbazingwekkende honderdvoudige toename.</p>
<h2 id="h2-Rifampicine20RIF656086"><a name="Rifampicine (RIF)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rifampicine (RIF)</h2><p>Rifampicine is een BIO-ecosysteem Meme, dat het <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">samengesteld</a> rifampicine. Rifamycine (RIF), als antibioticum, wordt traditioneel gebruikt voor de behandeling van tuberculose en andere ziekten.</p>
<p>Echter hebben onderzoekers de afgelopen jaren ontdekt dat het onverwachte effecten kan hebben op veroudering. Bij kleine organismen zoals C. elegans, een modelorganisme dat vaak wordt gebruikt in verouderingsonderzoek, is aangetoond dat RIF de natuurlijke verdedigingsmechanismen van cellen activeert, stress en schade bestrijdt, en de levensduur van deze organismen verlengt.</p>
<p>Hoewel het momenteel onduidelijk is of rifampicine hetzelfde effect kan hebben bij mensen, heeft zijn vermogen om de celgezondheid te bevorderen het tot een veelbesproken onderwerp gemaakt in onderzoek naar anti-verouderingstherapie.<img src="https://gimg2.gateimg.com/image/article/17321776244.jpeg" alt=""><br>Bron: pump.science</p>
<h2 id="h2-Urolithin20A20URO493933"><a name="Urolithin A (URO)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Urolithin A (URO)</h2><p>Urolithin (URO) is een verbinding die het menselijk lichaam produceert bij het consumeren van voedingsmiddelen die rijk zijn aan ellagische tannines, zoals granaatappel.</p>
<p>Het heeft een speciale ‘celreinigingsfunctie’, die oude en disfunctionele mitochondriën (de energiefabriek van cellen) kan verwijderen, waardoor verse en gezonde mitochondriën kunnen gedijen.</p>
<p>Dit proces wordt mitophagy genoemd en is aangetoond om de levensduur van C. elegans te verlengen, waardoor de cellen efficiënter en levendiger worden.</p>
<p>In menselijk onderzoek hebben urolithen ook potentieel getoond om spiergezondheid en energie te verbeteren, wat goed nieuws is voor deze twee aspecten die geleidelijk afnemen met de leeftijd.<br><img src="https://gimg2.gateimg.com/image/article/17321776545.jpeg" alt=""><br>Bron: pump.science</p>
<h2 id="h2-SciHubSCIHUB198961"><a name="Sci-Hub（SCIHUB）" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sci-Hub（SCIHUB）</h2><p>Sci-Hub wordt beschouwd als een pionier van de DeSci-beweging en is uitgegroeid tot een database met 88.343.822 onderzoeksartikelen en boeken. Met een wereldwijd verkeer van maximaal 60.000 bezoeken per uur trekt het de aandacht van talloze wetenschappers en ingenieurs en vormt het een sterke gemeenschapsconsensus.</p>
<p>Het Sci Hub-platform zelf is een DeSci-platform dat zich richt op het verstrekken van gratis academische hulpbronnen en e-bookdiensten. Het kernconcept is dat menselijke kennis vrij moet zijn en niet gemonopoliseerd mag worden door academische autoriteiten en uitgevers. Dit concept reageert op de wijdverbreide vraag naar toegang tot academische hulpbronnen, vooral wanneer geconfronteerd met hoge abonnementskosten en strikte auteursrechtbeperkingen.<img src="https://gimg2.gateimg.com/image/article/17321776746.jpeg" alt=""><br>Bron: sci-hub.se</p>
<p>Sci Hub werkt ook samen met andere DeSci-projecten zoals Ocean Protocol, BIO Protocol en Dlifexyz om wetenschappelijk onderzoek en gegevensuitwisseling te bevorderen. Deze projecten stellen meer mensen in staat om vrijelijk toegang te krijgen tot en wetenschappelijke kennis te delen via gedecentraliseerde datamarkten, tokenisatie van wetenschappelijk intellectueel eigendom en monetisatie van het digitale leven, wat de ontwikkeling van DeSci verder bevordert.</p>
<p>De marktkapitalisatie van de Meme coin scihub met dezelfde naam is gestegen tot $38 miljoen, en de handel is zeer actief.<br><img src="https://gimg2.gateimg.com/image/article/17321776927.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Het is vermeldenswaard dat alle drie de toonaangevende tokens zijn genoteerd op Gate.io.</p>
<h2 id="h2-Samenvatting801534"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Zoals hierboven te zien is, heeft het DeSci-veld als opkomend veld dat kan worden gecombineerd met real-world toepassingen, recentelijk de aandacht getrokken van veel investeerders en kapitaalstromen.</p>
<p>In tegenstelling tot traditionele Meme-munten, die puur entertainmenteigenschappen hebben, proberen DeSci Meme-munten vaak wetenschappelijk onderzoek en educatieve projecten te combineren, waardoor er een extra laag van betekenis en waarde wordt toegevoegd, waardoor een groep mensen wordt aangetrokken die technologische innovatie en maatschappelijke bijdrage nastreven.</p>
<p>In feite zijn er inderdaad enkele DeSci-projecten zoals Sci Hub die een zekere mate van innovatie en praktisch nut hebben, maar uiteraard werden deze nieuwe dingen ook bekritiseerd. De hieruit voortvloeiende Meme-munten kunnen helpen om de interesse van het publiek en het bewustzijn van DeSci tot op zekere hoogte te vergroten, nieuwe kanalen te openen voor het inzamelen van fondsen voor wetenschappelijk onderzoek, en zelfs meer mensen aan te moedigen om deel te nemen aan wetenschappelijke onderzoeksactiviteiten.</p>
<p>Om echter terug te komen op het punt, bevinden zich nog veel DeSci-projecten in hun beginfase en bestaan er onzekerheden met betrekking tot technologie, financiering en wetgeving. De kortetermijnhype rond veel Meme-munten is het gevolg van marktgedrag, en investeerders moeten rationeel blijven en  zijn op mogelijke risico’s.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Charle Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>