V2F0IHppam4gZGUgY2F0ZWdvcmllw6tuIHZhbiBEZVBpbj8gWmFsIERlUGluIGluIDIwMjUgZXhwbG9kZXJlbj8=

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt="">
</p><p>Het artikel van vandaag zal worden verdeeld in vijf delen:</p>
<ul>
<li>een korte introductie van het concept van DePIN,</li><li>de vier categorieën van DePIN en hun overeenkomstige projectlijsten,</li><li>de situatie van het DePIN-project in verschillende blockchain-netwerken,</li><li>diverse DePIN-marktwaarden die recent de moeite van het volgen waard zijn,</li><li>en de explosieve groei van DePIN in 2025.</li></ul>
<p>De DePIN-sector, vaak genoemd bij het bespreken van gedecentraliseerde infrastructuur of crypto DePIN, heeft een opmerkelijke groei laten zien, met een marktkapitalisatie van $32 miljard in 2025, met een toename van institutionele investeringen, bedrijfsadoptie en verbeterde cross-chain infrastructuur.</p>
<p>Gate-gegevens geven groeiende handelsvolumes aan over DePIN-tokens, wat wijst op aanhoudende interesse van investeerders in fysieke infrastructuur blockchain-oplossingen. Velen zien DePIN nu als een essentieel onderdeel van het bouwen van gedecentraliseerde netwerken en het stimuleren van de toekomst van gedecentraliseerde technologie.</p>
<p>De betekenis van DePIN gaat verder dan alleen een trend; het vertegenwoordigt de verschuiving naar gedecentraliseerde systemen en gedecentraliseerde platforms die digitale systemen verbinden met werkelijke toepassingen in de echte wereld.</p>
<h2 id="h2-Zal20DePIN20in20202520ontploffen336457"><a name="Zal DePIN in 2025 ontploffen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal DePIN in 2025 ontploffen?</h2><p>Naarmate 2025 zich ontvouwt, heeft de DePIN-sector - centraal in discussies over gedecentraliseerde netwerkontwikkeling en wat DePIN-crypto is - een opmerkelijke uitbreiding in marktkapitalisatie laten zien, die $32 miljard heeft bereikt - bijna driemaal zo groot als de waarde van $11 miljard in 2024.</p>
<p>Deze groeitraject benadrukt de cruciale rol van DePIN in de gedecentraliseerde web- en cryptoinfrastructuurruimte.</p>
<p>Verschillende belangrijke ontwikkelingen kenmerken het landschap van DePIN 2025:</p>
<ul>
<li>Institutionele investeringsstromen zijn versneld, waarbij durfkapitaalfondsen toegewijde DePIN-portefeuilles toewijzen, waarbij ze hun geloof in gedecentraliseerde architectuur en blockchain-infrastructuur benadrukken.</li><li>De acceptatie door bedrijven is toegenomen in sectoren zoals telecommunicatie, productie en gezondheidszorg, wat een bredere verschuiving naar gedecentraliseerde netwerken en gedecentraliseerde internetdiensten laat zien.</li><li>De integratie van cross-chain infrastructuur heeft de interoperabiliteit tussen belangrijke DePIN-netwerken verbeterd, wat de evolutie van gedecentraliseerde draadloze systemen en gedecentraliseerde wifi-initiatieven ondersteunt.</li></ul>
<p>De DePIN-markt biedt aanzienlijke kansen, zoals geïllustreerd door de vergelijkende marktpenetratie, wat verder de gedachte bevestigt dat gedecentraliseerde systemen essentieel zijn voor internetdecentralisatie en de bredere blockchainwereld.</p>
<table>
<thead>
<tr>
<th style="text-align:left">Sector</th>
<th style="text-align:left">Traditionele marktomvang</th>
<th style="text-align:left">DePIN Markt aandeel</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left">Cloud Computing</td>
<td style="text-align:left">$5 biljoen</td>
<td style="text-align:left">0.4%</td>
</tr>
<tr>
<td style="text-align:left">IoT-infrastructuur</td>
<td style="text-align:left">$1.3 biljoen</td>
<td style="text-align:left">0.8%</td>
</tr>
<tr>
<td style="text-align:left">Gegevensdiensten</td>
<td style="text-align:left">$720 miljard</td>
<td style="text-align:left">1.1%</td>
</tr>
</tbody>
</table>
<p>Gate-data geeft groeiende handelsvolumes aan over DePIN-tokens, wat wijst op aanhoudende interesse van investeerders in gedecentraliseerde netwerkoplossingen zoals DePIN-cryptoprojecten.</p>
<p>Met platforms zoals DePIN Hub die de discussie leiden rond depin blockchain en fysieke infrastructuurdiensten, staat de sector op het punt om een fundament te worden van het toekomstige internet.</p>
<p>Naarmate gedecentraliseerde systemen blijven rijpen, zullen het bouwen van gedecentraliseerde netwerken en het adopteren van gedecentraliseerde webtechnologieën belangrijke trends blijven in de cryptoruimte.</p>
<p>De groeitrajectorie van DePIN geeft aan dat gedecentraliseerde fysieke infrastructuurnetwerken nog maar net zijn begonnen.</p>
<p>Deze dagen heb ik opnieuw wat informatie over DePIN gelezen, in combinatie met referenties. <a href="/price/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">IoTeX</a> Enkele gegevensrapporten, laten we vandaag wat inhoud delen over dit onderwerp. Het artikel van vandaag zal worden verdeeld in vier delen: een korte introductie van het concept van DePIN, de vier categorieën van DePIN en hun bijbehorende projectlijsten, de situatie van het DePIN-project in verschillende blockchain-netwerken, en enkele DEP-marktwaarden die recent de aandacht verdienen.<br><img src="https://gimg2.gateimg.com/image/article/1704784874640.jpeg" alt="">
</p><p>DePIN (Decentralized physical infrastructure) vertaalt rechtstreeks naar gedecentraliseerde fysieke infrastructuur. Dit concept is ontstaan in 2022 toen Messari, een blockchain data-onderzoeksinstituut met hoofdkantoor in New York, een enquête uitbracht om een officiële titel te zoeken voor ‘Web3 fysieke infrastructuur’. In deze verzameling waren titels zoals Physical Proof of Work (PoPw), Token Incentivized Physical Network (TIPIN), EdgeFi, en Decentralized Physical Infrastructure Network (DePIN) allemaal opties. Uiteindelijk kwam DePIN als winnaar uit de stemming en begon de aandacht te trekken van sommige mensen.</p>
<p>Het grootste verschil tussen DePIN en traditionele netwerken (zoals mobiele netwerken, Alibaba Cloud services, enz.) is dat DePIN tokens gebruikt om de implementatie van fysieke infrastructuur te starten, waarbij blockchain technologie wordt ingezet om echte fysieke infrastructuur en hardware netwerken op een toestemmingsloze, betrouwbare en programmeerbare manier te bouwen en te exploiteren, waardoor grootschalige netwerkeffecten ontstaan en verschillende innovatieve DApps op basis van echte data worden ontsloten.</p>
<p>Op welke blockchainnetwerken zijn de huidige projecten onder het DePIN-concept voornamelijk gebouwd? Er zijn er voornamelijk 4, namelijk <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>、 <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>、 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> IoTeX.</p>
<p>Laten we nu doorgaan met het delen van de marktwaarde van verschillende DEP-projecten op basis van het vorige artikel:</p>
<h2 id="h2-Het20eerste20project20is20Krest20momenteel20gewaardeerd20op201520miljoen42853"><a name="Het eerste project is Krest (momenteel gewaardeerd op $15 miljoen)." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het eerste project is Krest (momenteel gewaardeerd op $15 miljoen).</h2><p>Krest is het kanarie netwerk van het peaq-netwerk, en het is ook het eerste IoT-economische simulatienetwerk. Het heeft tot doel innovatie en experimenten binnen het Peak-ecosysteem te bevorderen, waardoor de Peak-gemeenschap dApps en tools kan lanceren om hun impact te beoordelen zonder rekening te houden met reële wereldrisico’s.</p>
<p>Canary Network (ook bekend als Canarisch Netwerk) is een veelvoorkomende term in het veld van blockchain en netwerkbeveiliging. Dit concept vindt zijn oorsprong in de praktische toepassing in de mijnbouwsector. Wanneer giftige gassen verschijnen in ondergrondse mijnen, geven kanaries waarschuwingsoproepen af vanwege hun extreme gevoeligheid voor gassen, waardoor mijnwerkers op tijd worden herinnerd om te evacueren. In het veld van digitale versleuteling worden kanarische netwerken op een vergelijkbare manier gebruikt voor vroegtijdige detectie en waarschuwing van netwerkrisico’s.</p>
<p>Het projecttoken wordt voornamelijk gebruikt om te betalen voor de kosten, economische prikkels en beloningen van gemeenschapsplannen, zoals het verbinden van machinesimulatieapparaten.<br><img src="https://gimg2.gateimg.com/image/article/1704784919641.png" alt="">
</p><h2 id="h2-Het20tweede20project20is20Cere20Network20momenteel20gewaardeerd20op202520miljoen782725"><a name="Het tweede project is Cere Network (momenteel gewaardeerd op $25 miljoen)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het tweede project is Cere Network (momenteel gewaardeerd op $25 miljoen)</h2><p>Cere is een op blockchain gebaseerd ecosysteem voor klantrelatiebeheer, gericht op gedecentraliseerde datacloud, optimalisatie van servicegegevensintegratie en samenwerking. Het is ook <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Onderdeel van de Cosmos Alliance.<br><img src="https://gimg2.gateimg.com/image/article/1704784975642.png" alt="">
</p><h2 id="h2-Het20derde20project20is20Cudos20CUDOS20momenteel20gewaardeerd20op206520miljoen13039"><a name="Het derde project is Cudos (CUDOS, momenteel gewaardeerd op $65 miljoen)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het derde project is Cudos (CUDOS, momenteel gewaardeerd op $65 miljoen)</h2><p>Cudos is een gedecentraliseerd blockchain-netwerk dat schaalbare cloud computing resources biedt voor <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> ontwikkelaars en bedrijven, zoals virtuele machines voor het uitvoeren van dApps en AI-workloads. Ze bieden ook een zeer schaalbaar en kosteneffectief netwerk met een hoge bandbreedte, evenals cross-chain en multi-chain mogelijkheden.</p>
<p>65% van de maximale tokenvoorraad van het project is momenteel in omloop gebracht. De token werd gelanceerd in januari 2021 en zal volledig worden vrijgegeven binnen 10 jaar.<br><img src="https://gimg2.gateimg.com/image/article/1704785012643.png" alt="">
</p><h2 id="h2-Het20vierde20project20is20Wicrypt20momenteel20gewaardeerd20op201120miljoen20Amerikaanse20dollars351125"><a name="Het vierde project is Wicrypt (momenteel gewaardeerd op 11 miljoen Amerikaanse dollars)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het vierde project is Wicrypt (momenteel gewaardeerd op 11 miljoen Amerikaanse dollars)</h2><p>Wicrypt is een gedecentraliseerd netwerk bestaande uit routers (micro-nodes die draaien op een speciaal Wicrypt-besturingssysteem) en verbonden clients (zoals mobiele telefoons, computers, smart-tv’s, smartwatches en IoT-apparaten), waardoor gebruikers mobiel internet kunnen delen en er geld mee kunnen verdienen. Het fungeert als een virtuele internetprovider, waardoor gebruikers controle hebben over hun eigen gegevens. Gebruikers kunnen ondersteunde routers aanschaffen, Wicrypt firmware installeren en Wi-Fi-zones creëren. Anderen kunnen verbinding maken en toegang krijgen tot internet binnen bereik.</p>
<p>Op dit moment is 17% van de totale tokenvoorraad van het project in omloop.<br><img src="https://gimg2.gateimg.com/image/article/1704785050644.png" alt="">
</p><h2 id="h2-Het20vijfde20project20is20XYO20Network20momenteel20gewaardeerd20op208420miljoen20dollar872716"><a name="Het vijfde project is XYO Network (momenteel gewaardeerd op 84 miljoen dollar)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het vijfde project is XYO Network (momenteel gewaardeerd op 84 miljoen dollar)</h2><p>XYO is een blockchain voor het verifiëren van gegevens, die een reeks blockchain-standaarden en vastgestelde regels omvat voor het beheren van het ecosysteem en de gestructureerde gegevens ervan. De kerntechnologie is de Core Modules, die in feite een account of portemonnee zijn met soevereine classificaties, bestaande uit vier kernonderdelen: Sentinels (gegevensverzamelingscomponent), Bridges (gegevensoverdrachtscomponent), Archivists (gegevensopslagcomponent) en Diviners (component voor het samenvoegen van antwoorden).</p>
<p>De projecttoken wordt voornamelijk gebruikt als betaling voor diensten op het XYO-platform, evenals beloningen voor gebruikers die gegevens of diensten verstrekken. Het is momenteel voor 100% in omloop.<br><img src="https://gimg2.gateimg.com/image/article/1704785074645.png" alt="">
</p><h2 id="h2-Het20zesde20project20is20DIMO20Network20momenteel20gewaardeerd20op204620miljoen20Amerikaanse20dollars436790"><a name="Het zesde project is DIMO Network (momenteel gewaardeerd op 46 miljoen Amerikaanse dollars)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het zesde project is DIMO Network (momenteel gewaardeerd op 46 miljoen Amerikaanse dollars)</h2><p>DIMO is een IoT-platform dat gebruikers in staat stelt om hun gegevens op te slaan en selectief te delen. Het stelt bestuurders in staat om gegevens over hun voertuigen te verzamelen en te gebruiken voor winst. Ontwikkelaars en gegevensgebruikers kunnen toegang krijgen tot deze gegevens om bestaande bedrijven te verbeteren en nieuwe toepassingen te creëren.</p>
<p>Daarnaast stelt het ook bedrijven zoals Geico (de op vier na grootste autoverzekeringsmaatschappij in de Verenigde Staten), Tesla, Ford, Autozone (het op één na grootste automaterialenketenmerk in de Verenigde Staten), enz., in staat om controleerbare referenties uit te geven voor veiligheidstoepassingen.</p>
<p>Op dit moment is 15% van de totale tokenvoorraad van het project in omloop.<br><img src="https://gimg2.gateimg.com/image/article/1704785103646.png" alt="">
</p><p>Kortom, de opkomst van blockchaintechnologie lijkt al enkele industrieën te hebben veranderd of te zullen veranderen, zoals de bekende financiële sector (DeFi), game-industrie (GameFi), verzamelindustrie (NFT), enzovoort, maar dit vereist allemaal ondersteuning van de infrastructuur. In vergelijking met de huidige populariteit van NFT’s heeft DEP niet veel aandacht gekregen, maar we geloven dat DEP de mogelijkheid heeft om naadloos te integreren in de echte wereld, het monopolie van grote bedrijven te doorbreken en innovatie te bevorderen, wat zal leiden tot zijn enorme uitbreidingspotentieel.</p>
<p>Om nog maar te zwijgen van al het andere, de totale marktwaarde van de top tien cloudbedrijven wereldwijd bedraagt momenteel ongeveer 5 biljoen dollar, zoals te zien is in de onderstaande figuur. Als <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> bedrijven kunnen een klein deel van deze markt veroveren, hun waardering kan honderden miljarden dollars bereiken (de totale marktwaarde van alle versleutelde projecten in DEP is momenteel 11 miljard Amerikaanse dollars).<br><img src="https://gimg2.gateimg.com/image/article/1704785120647.png" alt="">
</p><p>Dus, het DePIN-concept kan veel aandacht trekken en aanzienlijke winsten genereren in de komende 6-18 maanden. Het is de moeite waard om van tevoren aandacht aan te besteden en te begrijpen. Het is echter belangrijk om eraan te herinneren dat ongeacht het vakgebied of project, altijd de bijbehorende risico’s te onthouden.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Praten buiten de praat</strong><br>  <div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen enkel handelsadvies.<br>    <div class="info-tips"></div>Dit artikel is overgenomen van Hualihua Wai en het auteursrecht behoort toe aan de oorspronkelijke auteur Hualihua Wai. Als u bezwaar heeft tegen de overname, neem dan contact met ons op voor verwijdering.<br><p></p><br></em></div></div></div>