V2F0IGlzIE5hbWFkYT8gRGUgdG9la29tc3QgdmFuIG11bHRpY2hhaW4gcHJpdmFjeSBvcG5pZXV3IGRlZmluacOrcmVu

2025-06-23, 10:37

<p><img src="https://gimg2.gateimg.com/image/namada202506231835035588911722.png" alt="">
</p><p>In de blockchainwereld is transparantie een tweesnijdend zwaard. Wanneer alle transactiegegevens openbaar toegankelijk zijn, wordt de privacy van de gebruiker blootgelegd—dit is precies het pijnpunt waarmee Namada zich bezighoudt. Als een Layer-1 blockchain die zich richt op privacybescherming binnen het Cosmos-ecosysteem, zal Namada in december 2024 officieel zijn mainnet lanceren, waarbij privacy wordt getransformeerd van een “optionele functie” naar de infrastructuur van een multi-chain ecosysteem door middel van innovatieve technologische architectuur. <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> De belangrijkste puzzel van privacybescherming.</p>
<h2 id="h2-Het20Privacy20Dilemma20van20Blockchain20Waarom20Is20Namada20Tot20Stand20Gekomen159279"><a name="Het Privacy Dilemma van Blockchain: Waarom Is Namada Tot Stand Gekomen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Privacy Dilemma van Blockchain: Waarom Is Namada Tot Stand Gekomen?</h2><p>De huidige blockchain staat voor drie privacy dilemma’s:</p>
<ol>
<li>Transparantie op-chain blootstelling: Traditionele blockchains (zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en Ethereum) openbaar alle transactiedetails, waardoor gebruikersactiva en -activiteiten gemakkelijk traceerbaar zijn;</li><li>Fragmentatie van privacyoplossingen: Privacycoins zoals <a href="/price/zcash-zec" rel="nofollow noopener noreferrer" target="_blank">Zcash</a> ondersteunt alleen de privacy van enkele activa en kan niet opnieuw worden gebruikt over ketens;</li><li>Risico’s van cross-chain lekken: IBC-overdrachten of cross-chain brugoperaties onthullen transactiepaden en bedragen.</li></ol>
<p>Namada is geboren met het doel van “modulaire privacy” - gebruikers in staat stellen hun gegevens te beschermen in elke cross-chain interactie zonder afhankelijk te zijn van een specifieke keten of applicatie.</p>
<h2 id="h2-Kerntechnologie20Unified20Shield20Set20en20Shielding20Operations79718"><a name="Kerntechnologie: Unified Shield Set en Shielding Operations" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kerntechnologie: Unified Shield Set en Shielding Operations</h2><p>De doorbraak van Namada is gebaseerd op twee hoeksteen technologieën:</p>
<h3 id="h3-Genificeerde20Beschermde20Set20USS20MultiAsset20Privacy20Pool188381"><a name="Geünificeerde Beschermde Set (USS): Multi-Asset Privacy Pool" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Geünificeerde Beschermde Set (USS): Multi-Asset Privacy Pool</h3><ul>
<li>Multi-Asset Shielded Pool (MASP): Gebaseerd op <a href="/price/zcash-zec" rel="nofollow noopener noreferrer" target="_blank">Zcash</a> De Sapling-upgrade ondersteunt elk activum (zoals ATOM, OSMO, NFT) om hetzelfde privacyfonds te delen, waarmee de beperkingen van single-asset privacyfondsen worden doorbroken;</li><li>Gedeeld anonimiteitsset: Alle activatransacties delen een uniforme privacy-laag; hoe groter de poolgrootte, hoe sterker de anonimiteit;</li><li>Vloeibare privacy: Activa kunnen vrij worden overgedragen binnen de afgeschermde set zonder dat hiervoor een vergrendeling nodig is.</li></ul>
<h3 id="h3-Shielding20Operatie20SA20CrossChain20Privacy20Automatisering17350"><a name="Shielding Operatie (SA): Cross-Chain Privacy Automatisering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Shielding Operatie (SA): Cross-Chain Privacy Automatisering</h3><p>Gebruikers kunnen complexe cross-chain operaties initiëren vanuit de shielding set, waarbij hun identiteit gedurende het proces verborgen blijft. Typische scenario’s zijn:</p>
<ul>
<li>Beschermde Staking: Privéoverdracht van ATOM naar <a href="/price/cosmos-hub-atom" rel="nofollow noopener noreferrer" target="_blank">Cosmos Hub</a> Staking;</li><li>Shield Swap: in <a href="/price/osmosis-osmo" rel="nofollow noopener noreferrer" target="_blank">Osmosis</a> Na het uitwisselen van privé-activa, keer terug naar Namada om opnieuw te schilden;</li><li>Gegevenspublicatie: Gebruik TIA om te betalen voor privé-transacties op Celestia en publiceer gegevens.</li></ul>
<p>Sleutelontwerp: Alle operaties vinden plaats binnen de afgeschermde set, en externe waarnemers kunnen alleen zien “geïnitieerd vanuit Namada USS” zonder de bron te kunnen traceren.</p>
<h2 id="h2-NAM20Token20De20brandstof20voor20de20privacyeconomie369672"><a name="NAM Token: De brandstof voor de privacy-economie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NAM Token: De brandstof voor de privacy-economie</h2><p>NAM is de native token van het Namada-ecosysteem, met een totale voorraad van 1 miljard munten. Momenteel, met een stakingpercentage van 40%, is het jaarlijkse rendement voor het staken van NAM ongeveer 12,5%. De NAM-token vervult vier kernfuncties:</p>
<table>
<thead>
<tr>
<th>Functie</th>
<th>Mechanisme Beschrijving</th>
</tr>
</thead>
<tbody>
<tr>
<td>Cyberbeveiliging</td>
<td>Het aannemen van Cube Proof of Stake (CPoS): Strafmaatregelen groeien exponentieel met het aantal samenspannende overtreders, resistent tegen samenspanningaanvallen.</td>
</tr>
<tr>
<td>Privacy Rewards</td>
<td>Gebruikers kunnen activa storten in de afgeschermde pool om SSR-beloningen te ontvangen, en het protocol transformeert privacy in een publiek goed.</td>
</tr>
<tr>
<td>Bestuursstemmen</td>
<td>Stake NAM om deel te nemen aan on-chain stemmen, waarbij beslissingen worden genomen over protocol-upgrades en fondsallocatie.</td>
</tr>
<tr>
<td>Publieke Goederen Fonds (PGF)</td>
<td>Sommige inflatiefondsen worden gebruikt om ecologische ontwikkeling te financieren en duurzame groei te bevorderen.</td>
</tr>
</tbody>
</table>
<h2 id="h2-Mainnet20Vooruitgang20en20Toekomstige20Uitbreiding676393"><a name="Mainnet Vooruitgang en Toekomstige Uitbreiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainnet Vooruitgang en Toekomstige Uitbreiding</h2><p>Namada hanteert een voorzichtige 5-fasen lancering strategie:</p>
<ul>
<li>December 2024: Mainnet lancering, staking en governance geopend;</li><li>Juni 2025: Laatste fase voltooid, NAM-tokens open voor handel, liquiditeitsmarkt gestart.</li></ul>
<p>Momenteel zijn IBC-activa (zoals <a href="/price/cosmos-hub-atom" rel="nofollow noopener noreferrer" target="_blank">Cosmos Hub</a> en Osmosis) worden ondersteund, en er zijn plannen om in de toekomst uit te breiden naar Ethereum, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> en <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (via Babylon-integratie), met als doel een full-stack privacylaag te worden.</p>
<h2 id="h2-Conclusie20De20Toekomst20van20Privacy20als20Publiek20Goed465417"><a name="Conclusie: De Toekomst van Privacy als Publiek Goed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: De Toekomst van Privacy als Publiek Goed</h2><p>De visie van Namada gaat verder dan technologie - het streeft ernaar de economische logica van privacy te reconstrueren:</p>
<ul>
<li>Door de bijdragen aan de privacy van gebruikers om te zetten in winstgevende openbare goederen via beschermde setbeloningen;</li><li>Met een modulaire architectuur kunnen alle on-chain activa en applicaties privacyfunctionaliteiten verkrijgen zonder modificatie.</li></ul>
<p>Met de lancering van NAM-handel op beurzen zoals Gate en de vooruitgang van multi-chain integratie, maakt Namada “privacy” de standaardinstelling voor <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> gebruikers.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="9">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>