Q2hlIGNvc1wnw6ggRmFudG9tIChGVE0pPyBMYSB0ZXJ6YSBibG9ja2NoYWluIERlRmkgcGnDuSBncmFuZGUgZGVsIDIwMjU=

2022-04-19, 04:04

<p><img src="https://gimg2.gateimg.com/image/ftm202506091108418390927989.png" alt="">
</p><h2 id="h2-Che20cos20Fantom20FTM505925"><a name="Che cos’è Fantom (FTM)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> (FTM)?</h2><p>Entro il 2025, <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> sarà comunque una blockchain Layer-1 ad alte prestazioni progettata per essere più veloce, economica e interoperabile rispetto alle piattaforme tradizionali. Con una capacità di elaborazione di oltre 20.000 transazioni al secondo e finalità in meno di un secondo, Fantom è diventata il terzo ecosistema DeFi più grande con un TVL di 4,5 miliardi di dollari. Questa rete compatibile con EVM supporta oltre 1.250 dApps e mantiene il 67% dei token FTM staked, migliorando significativamente la sua sicurezza e stabilità attraverso protocolli di bridging avanzati, fornendo al contempo un’interoperabilità cross-chain avanzata.</p>
<h2 id="h2-Gli20ultimi20sviluppi20di20Fantom20FTM20nel202025828013"><a name="Gli ultimi sviluppi di Fantom (FTM) nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli ultimi sviluppi di Fantom (FTM) nel 2025</h2><p>Entro il 2025, Fantom (FTM) ha consolidato la sua posizione nell’ecosistema DeFi e ha raggiunto diversi progressi significativi. La rete ha ampliato la sua capacità di throughput, ora in grado di elaborare oltre 20.000 transazioni al secondo mantenendo una finalità sotto il secondo. Questo miglioramento tecnologico ha attratto un gran numero di sviluppatori, con oltre 500 nuove dApps implementate negli ultimi sei mesi. <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> sulla rete Opera.</p>
<p>Il token FTM dimostra un’eccellente stabilità nelle prestazioni di mercato, con un tasso di partecipazione allo staking che raggiunge il 67% dell’offerta circolante. Questo alto rapporto di staking aiuta a migliorare la sicurezza della rete e a ridurre la volatilità del prezzo del token.</p>
<table>
<thead>
<tr>
<th>Indicatore</th>
<th>2023</th>
<th>2025</th>
</tr>
</thead>
<tbody>
<tr>
<td>TVL in DeFi</td>
<td>1,2 miliardi di USD</td>
<td>45 miliardi di USD</td>
</tr>
<tr>
<td>Volume di trading giornaliero</td>
<td>750.000</td>
<td>3.200.000</td>
</tr>
<tr>
<td>Sviluppatori Attivi</td>
<td>1.200</td>
<td>4.800</td>
</tr>
<tr>
<td>dApp distribuiti</td>
<td>320</td>
<td>1.250</td>
</tr>
</tbody>
</table>
<p>Gate continua a supportare la crescita dell’ecosistema Fantom migliorando le coppie di trading e integrando soluzioni di staking. La piattaforma ha lanciato pool di liquidità FTM dedicati, consentendo agli utenti di massimizzare il loro potenziale di rendimento mentre beneficiano delle performance di Fantom come il terzo più grande Blockchain DeFi per valore totale bloccato.</p>
<p>Con l’implementazione di protocolli di bridging avanzati, l’interoperabilità cross-chain di Fantom è notevolmente migliorata, consentendo trasferimenti di asset senza soluzione di continuità tra le principali reti Blockchain e rafforzando la sua posizione come soluzione Layer-1 leader nell’evoluzione dello spazio della Finanza Decentralizzata.</p>
<h2 id="h2-Una20breve20discussione20sulla20terza20blockchain20DeFi20pi20grande2020Fantom20FTM866163"><a name="Una breve discussione sulla terza blockchain DeFi più grande - Fantom (FTM)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Una breve discussione sulla terza blockchain DeFi più grande - Fantom (FTM)</h2><h3 id="h3-Cos20Fantom20FTM591434"><a name="Cos’è Fantom (FTM)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Fantom (FTM)?</h3><p>Fantom è un progetto di criptovaluta Layer-1 volto a diventare una piattaforma più veloce, economica e interoperabile, compatibile con il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Macchina Virtuale (EVM), che è la piattaforma fondamentale per costruire progetti Ethereum.</p>
<h3 id="h3-Come20funziona20Fantom149820"><a name="Come funziona Fantom?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona Fantom?</h3><p>Fantom funziona attraverso una struttura blockchain aggiornata nota come Grafo Diretto Acyclico, che consente alla rete di eseguire la convalida delle transazioni in modo più rapido, economico ed efficiente. Raggiunge questo anche grazie alla sua tolleranza ai guasti bizantini asincrona: consente a diverse convalide di avvenire simultaneamente sulla rete, fornendo allo stesso tempo uno spazio di integrazione per altre piattaforme architettoniche oltre EVM.</p>
<h3 id="h3-Che20cos20il20token20FTM75845"><a name="Che cos’è il token FTM?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è il token FTM?</h3><p>FTM è il protocollo nativo della rete, utilizzato per le transazioni, la governance e per premiare i validatori della rete con le commissioni di transazione.</p>
<h3 id="h3-Come20acquistare20FTM925238"><a name="Come acquistare FTM:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare FTM:</h3><p>Dopo aver creato un account su Gate, seleziona “Trading” dalla barra del menu superiore sulla homepage del sito ufficiale e clicca su “Spot Trading” per acquistare FTM. Una volta entrato nella pagina di trading, cerca Fantom o FTM nell’angolo in alto a sinistra della pagina per vedere quali coppie sono disponibili per il trading.</p>
<h3 id="h3-Come20conservare20FTM543696"><a name="Come conservare FTM:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come conservare FTM:</h3><p>Quando acquisti asset su Gate, ti vengono immediatamente forniti servizi di custodia all’avanguardia, ai quali puoi accedere tramite il menu del portafoglio nell’angolo in alto a destra. Vai semplicemente su “Panoramica Fondi” per selezionare l’account di cui vuoi visualizzare gli asset.</p>
<h3 id="h3-Come20mettere20in20staking20FTM458132"><a name="Come mettere in staking FTM:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come mettere in staking FTM:</h3><p>Gate offre opzioni di staking per migliaia di criptovalute, incluso lo staking di FTM. Se vuoi partecipare allo staking di Fantom, seleziona “Trading” dalla barra di menu in alto sulla homepage ufficiale, e fai clic su “ <a href="https://www.Gate/hodl?ch=ann839" rel="nofollow noopener noreferrer" target="_blank">Tesoro di Gestione Patrimoniale</a>”. Una volta entrato nella pagina, puoi vedere quali opzioni di staking di Fantom sono attualmente disponibili.</p>
<p>Questo articolo introdurrà brevemente uno dei progetti di criptovaluta più promettenti e ricchi di funzionalità oggi - Fantom (FTM). Dai suoi concetti di base e meccanismi generali al token FTM, possiamo percepire che Fantom è un progetto crypto estremamente grandioso.</p>
<h2 id="h2-Che20cos20Fantom20FTM489356"><a name="Che cos’è Fantom (FTM)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Fantom (FTM)?</h2><p>Fantom, creato nel 2018, è un progetto di criptovaluta Layer-1 con l’obiettivo di diventare una piattaforma più veloce, economica e interoperabile, compatibile con la <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Virtual Machine (EVM), che è la rete di piattaforma fondamentale per la costruzione di progetti compatibili con Ethereum. Fantom ha il proprio token nativo FTM, che, oltre a fungere da meccanismo di transazione tra gli utenti di Fantom, ha vari usi e framework di cui discuteremo più avanti in questo articolo.</p>
<p>La criptovaluta Fantom è stata proposta nel primo white paper ufficiale rilasciato dalla Fantom Foundation il 25 ottobre 2018. I suoi sviluppatori includono i computer scientist e sviluppatori Jiho Park, Sang-Min Choi, Quan Nguyen e Andre Cronje, noto soprattutto come fondatore di Yearn Finance (YFI). Nel white paper di Fantom, lo scopo della rete è molto semplice: creare una blockchain economica, più veloce e più sicura, compatibile con EVM attraverso due principali framework algoritmici: Directed Acyclic Graph e Asynchronous Byzantine Fault Tolerance – e così via, questi termini saranno approfonditi in questo articolo.</p>
<p>Sin dalla sua nascita, Fantom è gradualmente diventato uno dei progetti principali fino ad oggi. Con soluzioni crittografiche Layer-1 come Solana, <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> e <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> aumentando gradualmente nel 2020 e 2021, Fantom è rapidamente entrato sotto i riflettori come una piattaforma a basso costo provata, facile da costruire e con un enorme potenziale di scalabilità. Pertanto, a gennaio 2022, Fantom ha superato il <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Smart Chain per diventare il terzo blockchain DeFi più grande nello spazio crypto.</p>
<h2 id="h2-Come20funziona20Fantom297738"><a name="Come funziona Fantom?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona Fantom?</h2><p>Sebbene la Fantom Foundation sia stata istituita alla fine del 2018, la criptovaluta effettiva è stata attivata solo a dicembre 2019, quando la rete e il suo token FTM erano pronti per i test di battaglia, fungendo da mezzo per accedere a contratti compatibili con EVM attraverso diverse infrastrutture Blockchain. La rete Fantom è spesso chiamata Fantom Opera, funzionando sotto un livello di consenso Proof of Stake (PoS), dove i detentori del token FTM possono utilizzarlo per gestire nodi, convalidare transazioni e guadagnare ricompense.</p>
<p>L’uso del PoS rende Fantom una rete più ottimizzata per lo sviluppo di applicazioni decentralizzate (dApp), specialmente nel DeFi, rendendola compatibile con i principali progetti DEX e di prestito come Curve, <a href="/price/sushi-sushi" target="_blank" class="blog_inner_link">Sushi</a> o Dream Finance, co-fondato da Fantom, tutti i quali sfruttano il wallet MetaMask come intermediario.</p>
<h3 id="h3-DAG20il20pilastro20centrale20di20Fantom20Opera32576"><a name="DAG, il pilastro centrale di Fantom Opera" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DAG, il pilastro centrale di Fantom Opera</h3><p>Come accennato in precedenza, uno dei due principali framework che distingue Fantom è la sua struttura DAG, che sta per Grafo Diretto Acyclico. Il DAG può essere visto come una versione aggiornata del concetto di blockchain, con i suoi vantaggi rispetto ai modelli tradizionali. Puoi pensare a <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">il grafico</a> come un albero: in soldoni, il DAG è essenzialmente una catena composta da nodi e catene verticali (a differenza dei blocchi lineari di una blockchain), collegati da diversi rami che rappresentano il processo di transazione della rete. Pertanto, su Fantom, ogni nodo rappresenta una transazione specifica che viene elaborata contemporaneamente ad altre operazioni nella sua blockchain. Poiché la rete opera in modo asincrono, nuove operazioni e compiti possono iniziare e finire in qualsiasi momento: questo è diverso dai modelli di blockchain tradizionali, che sono lineari. Consente anche a Fantom Opera di tracciare l’intera rete in un registro continuamente aggiornato di operazioni collegate. La sua velocità è anche molto elevata, con conferme delle operazioni che richiedono meno di un secondo.</p>
<h3 id="h3-Tolleranza20ai20guasti20bizantini20asincrona460699"><a name="Tolleranza ai guasti bizantini asincrona" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tolleranza ai guasti bizantini asincrona</h3><p>L’aBFT di Fantom si chiama Lachesis, che può essere considerato il meccanismo di consenso dell’intero sistema. In futuro, Fantom sarà in grado di implementare più blockchain diverse all’interno della rete continuando a utilizzare Lachesis come protocollo di consenso centrale. Una delle caratteristiche di Lachesis è la sua natura asincrona e senza leader (completamente decentralizzata), che può tollerare fino a un terzo di nodi malevoli apparentemente istantanei (tolleranza ai guasti bizantini).</p>
<p>Il meccanismo di funzionamento è il seguente: Prima viene avviato il processo di sincronizzazione dei nodi, e poi viene eseguito un algoritmo di selezione casuale per iniziare a generare il prossimo Blocco nella Blockchain. Dopo la selezione, inizia la comunicazione tra i nodi scelti casualmente, sincronizzando la rete attraverso il meccanismo DAG per verificare le informazioni sulle transazioni del Blocco. Successivamente, le informazioni del Blocco vengono trasmesse ai nodi responsabili e, dopo la verifica, il processo viene approvato utilizzando il consenso aBFT per ripartire con il nuovo Blocco.</p>
<h2 id="h2-Che20cos20il20token20FTM764864"><a name="Che cos’è il token FTM?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è il token FTM?</h2><p>Come accennato in precedenza, FTM è il token nativo della rete Fantom: token simili in ERC-20 (Ethereum) e BEP-20 (BNB Chain) sono disponibili anche per l’uso. Il suo ruolo principale nella rete è quello di pagare le commissioni di validazione per il comitato di validazione dei nodi per verificare le transazioni, determinare soluzioni e governare on-chain, consentendo il voto su modifiche e aggiornamenti al progetto.</p>
<p>In termini di economia dei token, l’offerta di token FTM è limitata a 3,175 miliardi, con un’offerta circolante attuale di 2,54 miliardi. Man mano che la rete si espande, questi token vengono distribuiti quotidianamente, seguendo il framework mostrato di seguito:</p>
<p>· 40% allocato agli investitori in collocamenti pubblici e privati.</p>
<p>· 15% assegnato agli advisor, con un periodo di blocco di tre mesi.</p>
<p>· 10% assegnato ai fondatori, che sarà rilasciato due anni dopo il lancio della rete.</p>
<p>· Il 3,6% è destinato alle riserve strategiche designate per questo protocollo.</p>
<p>· Il 31,4% è utilizzato per premiare i nodi nella commissione di trading, che sarà distribuita entro la fine del 2024.</p>
<h2 id="h2-Come20acquistare20FTM610144"><a name="Come acquistare FTM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare FTM</h2><p>Il token nativo di Fantom, FTM, può essere acquistato su Gate. Gate offre vari servizi commerciali come depositi in contante, depositi in criptovalute, transazioni con carta di credito e trading P2P.</p>
<p>Creato su Gate exchange <a href="https://www.Gate/signup" rel="nofollow noopener noreferrer" target="_blank">Account</a> Dopo di ciò, seleziona l’opzione “Trading” dalla barra del menu in alto sulla homepage del sito ufficiale e clicca su “ <a href="https://www.Gate/trade/BTC_USDT?ch=ann839" rel="nofollow noopener noreferrer" target="_blank">Trading al dettaglio</a> Puoi acquistare FTM. Dopo essere entrato nella pagina di trading, cerca Fantom o FTM nell’angolo in alto a sinistra della pagina per vedere quali coppie possono essere scambiate - la coppia di trading più popolare al momento è FTM/USDT.</p>
<p>Se il tuo account ha già i fondi appropriati per la coppia di trading, puoi effettuare un ordine in qualsiasi momento!</p>
<h2 id="h2-Come20conservare20FTM617366"><a name="Come conservare FTM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come conservare FTM</h2><p>Quando acquisti asset su Gate, ti vengono immediatamente forniti i servizi di custodia più avanzati, ai quali puoi accedere tramite il menu del portafoglio nell’angolo in alto a destra. Basta andare su “Panoramica Fondi” per selezionare l’account i cui asset vuoi visualizzare.</p>
<h2 id="h2-Come20Staking20FTM583875"><a name="Come Staking FTM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come Staking FTM</h2><p>Gate offre opzioni di staking per migliaia di criptovalute, incluso lo staking di FTM. Se desideri partecipare allo staking di Fantom, seleziona “Trade” dal menu in alto sulla homepage ufficiale e fai clic su “Financial Products”. Una volta sulla pagina, puoi vedere le opzioni di staking di Fantom disponibili. Puoi anche scegliere liberamente qualsiasi altro asset disponibile sulla piattaforma Gate per investimenti e trading. Vai a controllare la piattaforma Gate per vedere quali opzioni di investimento ti interessano!</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="10">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>