TnVvdm8gdGlwbyBkaSByZXRlIChOS04pIC0gUHJvZ2V0dG8gaW5mcmFzdHJ1dHR1cmFsZSBwZXIgdW4gaW50ZXJuZXQgZGVjZW50cmFsaXp6YXRv

2025-04-24, 13:40

<p><img src="https://gimg2.gateimg.com/image/article/1745502357blog2.png" alt=""><br>Nuovo tipo di rete, di solito abbreviato in NKN, si posiziona come “il TCP/IP di <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a>.” Ricompensando chi condivide la larghezza di banda inutilizzata e la capacità di relay, la rete NKN mira a ricostruire lo strato di trasporto di Internet in una maglia aperta e resistente alla censura. Alimentato dalla moneta NKN, questo progetto infrastrutturale ha silenziosamente attivato oltre 180 000 nodi di relay autonomi, già la più grande rete peer-to-peer blockchain del pianeta.</p>
<h2 id="h2-Perch20il20Mondo20Ha20Bisogno20di20NKN985759"><a name="Perché il Mondo Ha Bisogno di NKN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il Mondo Ha Bisogno di NKN</h2><p>Il vecchio internet instrada il traffico attraverso ISP centralizzati e data center che creano punti di fallimento, sorveglianza e throttling. La visione decentralizzata di Internet di NKN sostituisce quel modello con milioni di relay volontari. Ogni relay guadagna micro-pagamenti in token NKN per inoltrare pacchetti, simile a come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> paga i minatori per l’hashing. Gli utenti ottengono una connettività a basso costo e resiliente; gli operatori di nodi monetizzano la larghezza di banda inutilizzata.</p>
<h2 id="h2-Come20Funziona20la20Rete20NKN197568"><a name="Come Funziona la Rete NKN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come Funziona la Rete NKN</h2><ul>
<li><p>Novel Proof‑of‑Relay (PoR) – Invece dell’intensivo consumo di elettricità del proof‑of‑work, NKN utilizza il PoR per verificare che i nodi trasmettano effettivamente i dati. I relè autorizzano il traffico che inoltrano, e la catena ispeziona casualmente un sottoinsieme per scoraggiare le pratiche fraudolente.</p>
</li><li><p>MOCA Consensus – Short for Majority vOte Cellular Automata, MOCA combines cellular automaton dynamics with Byzantine agreement to finalize blocks in seconds while scaling to hundreds of thousands of nodes.</p>
</li><li><p>d‑Chat &amp; nConnect – Applicazioni principali costruite su Gate che offrono messaggi crittografati end‑to‑end e desktop remoto sicuro senza server centralizzati. Ogni passaggio dati consuma piccole quantità di monete Gate, fornendo utilità in tempo reale e bruciando token.</p>
</li></ul>
<h2 id="h2-Tokenomica20di20Gate20Coin415561"><a name="Tokenomica di Gate Coin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tokenomica di Gate Coin</h2><p>| Metrica | Valore |<br>| ———— | ———— |<br>| Ticker | NKN |<br>| Offerta massima | 1 000 000 000 NKN |<br>| Circolante (aprile 2025) | ~760 M |<br>| Inflazione | 18 NKN per blocco, dimezza ogni ~2 anni fino al limite |<br>| Utilità | Ricompense per il mining di relay, commissioni di transazione, staking di PoR, votazioni DAO on‑chain |</p>
<p>Circa il 70 % delle attuali ricompense per i blocchi vanno ai relay attivi; il 20 % finanzia la Fondazione NKN per lo sviluppo, e il 10 % viene bruciato, creando una leggera pressione deflazionistica mentre le commissioni di rete aumentano.</p>
<h2 id="h2-Recenti20traguardi20che20guidano20il20prezzo20di20NKN441591"><a name="Recenti traguardi che guidano il prezzo di NKN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti traguardi che guidano il prezzo di NKN</h2><ul>
<li><p>Partner EdgeRouter (dicembre 2024): il produttore di router con sede a Shenzhen ha lampeggiato il firmware NKN su 50.000 dispositivi per consumatori, raddoppiando il conteggio dei relay giornalieri - il prezzo di NKN è aumentato del 35%.</p>
</li><li><p>Elenco del Marketplace di AWS (Feb 2025): Le imprese possono ora avviare facilmente i nodi commerciali NKN con un clic, pagando le commissioni in token NKN.</p>
</li><li><p>Gate.io Futures lancio (Mar 2025): coppia OMNI-perp con fino a 10x leva aperta, offrendo ai trader nuovi modi per coprire o speculare sul prezzo della moneta NKN.</p>
</li></ul>
<h2 id="h2-Roadmap202025202620di20NKN50923"><a name="Roadmap 2025–2026 di NKN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Roadmap 2025–2026 di NKN</h2><ol>
<li><p>nTransport SDK v2 – librerie Rust e Swift rivolte agli studi di sviluppo di giochi per dispositivi mobili per sessioni P2P senza lag.</p>
</li><li><p>Bandwidth NFT – Pacchetti di throughput prepagati tokenizzati negoziabili su qualsiasi catena EVM, pagati in criptovaluta NKN.</p>
</li><li><p>ZKP Privacy Relay – Integra le dimostrazioni a conoscenza zero in modo che i relè possano verificare l’integrità dei dati senza leggere i carichi utili, aumentando l’adozione aziendale.</p>
</li></ol>
<h2 id="h2-Casi20duso20che20si20espandono20oltre20la20condivisione20di20file691586"><a name="Casi d’uso che si espandono oltre la condivisione di file" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Casi d’uso che si espandono oltre la condivisione di file</h2><ul>
<li><p>CDN decentralizzato - le piattaforme multimediali pagano i nodi di rete NKN per memorizzare nella cache e distribuire i video più vicino agli spettatori.</p>
</li><li><p>Firmware IoT Push – I produttori trasmettono aggiornamenti tramite la rete NKN ai dispositivi con connettività intermittente.</p>
</li><li><p>Messaggistica resilienti ai disastri – le ONG utilizzano hotspot portatili NKN per ripristinare la comunicazione durante le interruzioni.</p>
</li></ul>
<h2 id="h2-Come20ottenere20e20conservare20NKN20Coin20su20Gateio793428"><a name="Come ottenere e conservare NKN Coin su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come ottenere e conservare NKN Coin su Gate.io</h2><ol>
<li><p>Commercio spot: Cerca coppie NKN/USDT o NKN/BTC su Gate.io per spread stretti e liquidità profonda.</p>
</li><li><p>Guadagna: Stake NKN in Gate Guadagna pool flessibili - le ricompense vengono auto‑composte in monete NKN.</p>
</li><li><p>Ritiro: utilizzare i ponti ERC-20 o Binance Smart Chain; i portafogli hardware come Ledger supportano NKN tramite MetaMask.</p>
</li></ol>
<p>Gate.io ospita occasionalmente contest e airdrop di trading a tema NKN; detenere almeno 500 NKN può sbloccare rimborsi sulle commissioni o aumenti di livello di Startup Launchpad.</p>
<h2 id="h2-Rischi20e20considerazioni20del20trading20NKN225517"><a name="Rischi e considerazioni del trading NKN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischi e considerazioni del trading NKN</h2><p>Sebbene il conteggio dei relay sia impressionante, il traffico effettivamente pagato rimane modesto; se l’adozione dell’app è in ritardo, il prezzo del token NKN potrebbe stagnare. Le restrizioni normative sull’estrazione tramite router domestici potrebbero anche frenare la crescita dei nodi. Come sempre, monitorare i commit su GitHub, gli aggiornamenti della mainnet e le statistiche mensili dei relay prima di investire.</p>
<h2 id="h2-Conclusione353635"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>New Kind of Network fornisce un pezzo tangibile di infrastruttura <a href="/web3" target="_blank" class="blog_inner_link">Web3</a>: uno strato di trasporto permesso e incentivato a cui chiunque con una larghezza di banda di riserva può unirsi. La moneta NKN allinea i premi economici con la salute della rete, mentre Gate.io fornisce un luogo sicuro per negoziare, puntare e monitorare questo emergente asset di connettività. Per gli appassionati di criptovalute che cercano esposizione alla spina dorsale di un internet decentralizzato, NKN merita un posto nell’elenco dei monitoraggi — e forse nel portafoglio.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Cinnie</strong>, Ricercatore 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 reinvio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>