Q2hlIGNvc1wnw6ggU3ludGhldGl4IChTTlgpPyBMYSBjcml0dG9ncmFmaWEgaW5jb250cmEgbGEgZmluYW56YSB0cmFkaXppb25hbGUgMjAyNQ==

2022-05-12, 18:05

<p><img src="https://gimg2.gateimg.com/image/syn202506161742157726913858.png" alt="">
</p><p>Che cos’è Synthetix? Synthetix è un protocollo di finanza decentralizzata (DeFi) creato per emettere e fornire “attività sintetiche” su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rete. Questi asset, noti come Synths, rappresentano tipicamente contenuti scambiati nel TradFi; spaziando da azioni, fondi, materie prime, a valute fiat, e altro ancora. Entro il 2025, Synthetix è evoluto nel pilastro del trading di derivati decentralizzati con la sua architettura V3, integrando Kwenta, Lyra e Derive per diventare un hub unificato di derivati DeFi, bloccando un valore di $1,2 miliardi, con un volume di scambi giornaliero di $420 milioni, e migliorando l’infrastruttura oracle per diventare il principale ponte tra TradFi e DeFi.</p>
<h2 id="h2-Ultimi20sviluppi20nel202025234611"><a name="Ultimi sviluppi nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimi sviluppi nel 2025</h2><p>Entro il 2025, Synthetix ha subito una trasformazione significativa, evolvendosi dalla sua visione iniziale nel pilastro del trading di derivati decentralizzati. L’architettura V3 della piattaforma sarà completamente implementata nel 2024, raggiungendo l’obiettivo di diventare un protocollo di derivati senza permessi con una scalabilità senza precedenti.</p>
<p>Il protocollo ha integrato con successo diversi progetti ecosistemici:</p>
<ul>
<li>Kwenta (trading spot/futures)</li><li>Lyra (opzioni)</li><li>Derive (acquisizione alla fine del 2024)</li></ul>
<p>Queste acquisizioni strategiche hanno reso Synthetix un hub di derivati DeFi unificato, piuttosto che un protocollo decentralizzato che condivide liquidità.</p>
<table>
<thead>
<tr>
<th>Indicatore</th>
<th>2023</th>
<th>2025</th>
</tr>
</thead>
<tbody>
<tr>
<td>Valore Bloccato</td>
<td>$310 milioni</td>
<td>1,2 miliardi di USD</td>
</tr>
<tr>
<td>Volume di trading giornaliero</td>
<td>50 milioni di USD</td>
<td>$420 milioni</td>
</tr>
<tr>
<td>capitalizzazione di mercato sUSD</td>
<td>125 milioni di USD</td>
<td>680 milioni di USD</td>
</tr>
</tbody>
</table>
<p>Dopo aver sperimentato un problema di decoupling all’inizio del 2024, la stabilità di sUSD è notevolmente migliorata. Gate ora offre servizi Synthetix potenziati, inclusi prodotti di staking SNX con leva e tassi di rendimento annuali competitivi e trading di asset sintetici cross-chain.</p>
<p>L’infrastruttura oracle di Synthetix è stata aggiornata, incorporando fonti di dati ridondanti, migliorando significativamente l’accuratezza dei prezzi e riducendo i rischi di manipolazione presenti nelle implementazioni precedenti.</p>
<p>Mentre la finanza tradizionale continua a fondersi con la DeFi, Synthetix funge da principale ponte tra questi due mondi, fornendo esposizione tokenizzata ai mercati globali senza le barriere tradizionali.</p>
<h2 id="h2-Crypto20Assets20e20TradFi20Hub2020Unanalisi20di20Synthetix20SNX988980"><a name="Crypto Assets e TradFi Hub - Un’analisi di Synthetix (SNX)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Assets e TradFi Hub - Un’analisi di Synthetix (SNX)</h2><h2 id="h2-Che20cos20Synthetix686096"><a name="Che cos’è Synthetix?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Synthetix?</h2><p>Synthetix è un protocollo finanziario decentralizzato (DeFi) utilizzato per lanciare e fornire “attività sintetiche” sulla rete Ethereum. Queste attività, conosciute come Synths, rappresentano tipicamente attività comunemente scambiate nel TradFi, come azioni, fondi, materie prime, valute fiat e altro.</p>
<h2 id="h2-Come20funziona20Synthetix362315"><a name="Come funziona Synthetix?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona Synthetix?</h2><p>Synthetix richiede alla piattaforma di creare diversi token, ognuno dei quali rappresenta un synth specifico, supportato da un collaterale, controllo dell’inflazione, governance e sistema di commissioni. Ad esempio, sSilver può essere un token che rappresenta il mercato globale dell’argento. Per garantire che il prezzo del token corrisponda al prezzo reale, vengono utilizzati oracoli blockchain per connettere i due ambiti e fornire informazioni in tempo reale e costantemente accurate.</p>
<h2 id="h2-Token20SNX269061"><a name="Token SNX:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token SNX:</h2><p>A causa della sua offerta limitata - un totale di 255 milioni di monete, SNX ha due funzioni principali: è il token obbligatorio richiesto per creare Synths, utilizzato come garanzia attraverso lo staking, e funge da meccanismo di governance, permettendo ai detentori di SNX di votare su proposte di miglioramento.</p>
<h2 id="h2-Come20acquistare20SNX380790"><a name="Come acquistare SNX:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare SNX:</h2><p>Devi solo creare un account sull’exchange Gate. <a href="https://www.gate.com/signup" target="_blank"><em>Account Gate</em></a> poi vai nell’area di trading e seleziona <a href="https://www.gate.com/trade/BTC_USDT?ch=ann974" target="_blank"><em>trading spot</em></a> Puoi effettuare un acquisto. Dopo aver aperto la pagina di trading spot, cerca Synthetix o SNX nella barra di ricerca nell’angolo in alto a sinistra per vedere quali coppie di trading sono disponibili per il trading.</p>
<h2 id="h2-Come20conservare20SNX365074"><a name="Come conservare SNX:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come conservare SNX:</h2><p>Una volta acquistati gli asset su Gate, puoi immediatamente godere di servizi di gestione degli asset di alta qualità, che possono essere accessibili tramite il menu del portafoglio nell’angolo in alto a destra della homepage del sito ufficiale. Basta inserire <a href="https://www.gate.com/myaccount/myfunds" target="_blank"><em>Panoramica del Fondo</em></a> Nella pagina, seleziona l’account per gli asset che desideri visualizzare.</p>
<h2 id="h2-Come20mettere20in20staking20SNX682385"><a name="Come mettere in staking SNX:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come mettere in staking SNX:</h2><p>Gate offre soluzioni di staking per migliaia di crypto asset, incluso lo staking di SNX. Se desideri fare staking su Synthetix, vai al menu Gate finance nella barra del menu in alto del sito ufficiale e poi clicca <a href="https://www.gate.com/hodl?ch=ann974" target="_blank"><em>Gestione Patrimoniale Tesoro</em></a> Dopo aver effettuato l’accesso alla pagina Wealth Management, fai clic sulla categoria Conto Corrente per visualizzare quali opzioni Synthetix sono attualmente disponibili.</p>
<p>Il mondo finanziario è dominato da azioni, valute, attivi netti, materie prime e altri scambi provenienti dai mercati e dalle borse valori di tutto il mondo. Sebbene il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è cresciuto significativamente negli ultimi 13 anni, ma è ancora lontano dalla scala da trilioni di dollari del TradFi.</p>
<p>Tuttavia, offre un’opportunità per collegare questi due mondi. E se il TradFi potesse anche avventurarsi nei Crypto Assets, ottenendo accesso attraverso una risorsa decentralizzata più facilmente ottenibile e investibile? Questo è esattamente l’obiettivo che Synthetix mira a raggiungere. Per ottenere queste funzionalità, il progetto ha creato diversi strumenti decentralizzati che consentono al mercato dei Crypto Assets di interagire e diventare un hub per il TradFi.</p>
<p>In questo articolo, sveleremo cos’è Synthetix e come avvicina il mercato delle criptovalute e il TradFi.</p>
<h2 id="h2-Che20cos20Synthetix581400"><a name="Che cos’è Synthetix?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Synthetix?</h2><p>Synthetix è un protocollo di finanza decentralizzata (DeFi), il cui nome completo è <a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">Synthetix Network</a> Token (SNX), utilizzato per lanciare e fornire “asset sintetici” sulla rete Ethereum. Il token SNX garantisce la disponibilità e il finanziamento di questi asset, ed è responsabile per consentire l’esistenza degli asset sintetici on-chain e per interagire con la piattaforma. Questi asset possono rappresentare quasi tutto, ma il focus è su TradFi; da azioni a fondi, merci e valute fiat, appartengono tutte alle principali categorie di asset della finanza tradizionale.</p>
<p>Lo scopo di Synthetix è fornire agli utenti un facile accesso ai mercati tradizionali. La maggior parte delle persone potrebbe pensare il contrario; che gli asset cripto siano più difficili da ottenere rispetto alla finanza tradizionale. In realtà, la finanza tradizionale richiede molte procedure di conformità e se i nuovi utenti non hanno un record di investimento affidabile o non hanno un conto di risparmio centrale sufficientemente grande per dimostrare la loro esperienza di investimento, la maggior parte degli exchange non accetterà nuovi account utente. Per non parlare delle commissioni, che nella finanza tradizionale hanno superato livelli sostanziali. Con la piattaforma Synthetix, possono essere creati asset sintetici di qualsiasi tipo che la piattaforma desideri.</p>
<h2 id="h2-Che20cos20Synth441891"><a name="Che cos’è Synth?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è Synth?</h2><p>Ma cosa sono esattamente gli asset sintetici? Su Synthetix, vengono chiamati “Synths.” Gli Synths sono essenzialmente versioni sintetiche digitali di asset di altri mercati, completamente separati dagli asset Crypto. Lo scopo di creare questi asset è quello di parallelarli con questi mercati – interagire e godere delle proprietà di questi asset senza doverli possedere completamente. Con gli Synths, gli utenti possono accedere a diversi asset provenienti da tutti i tipi di mercati in tutto il mondo senza dover affrontare i tradizionali problemi di processi come custodia, tassazione basata sugli asset e altre esigenze che possono sorgere dalle transazioni TradFi. Allo stesso tempo, sfrutteranno anche fattori benefici, come l’apprezzamento del valore portato dalla volatilità del mercato e la possibilità di scambiare e vendere quando necessario.</p>
<h2 id="h2-Come20funziona20Synthetix387166"><a name="Come funziona Synthetix?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona Synthetix?</h2><p>Un sistema di ricompensa rapidamente decomponibile consente agli utenti di creare nuovi Synth per guadagnare ricompense in token SNX.</p>
<p>Synthetix richiede alla piattaforma di creare diversi token, ognuno dei quali rappresenta un synth specifico all’interno della piattaforma. Ogni synth è supportato da un collaterale di finanziamento, controllo dell’inflazione, governance e sistema delle commissioni.</p>
<p>Ad esempio, se qualcuno desidera creare un synth che rappresenti il mercato dell’argento, Synthetix creerà un nuovo token per questo synth—possibilmente sotto il titolo di sSilver (il primo “s” sta per sintetico). Questo nuovo token all’interno della rete Synthetix sarà unificato da un framework di governance basato su smart contract, insieme a tutti i progetti e le applicazioni DeFi. Questo framework funge da infrastruttura di garanzia del sistema, progettato per evitare perdite temporanee, controllare l’inflazione e garantire che ogni synth operi come previsto. Dopotutto, ogni synth rappresenta non un asset statico, ma piuttosto un asset imprevedibile e volatile che richiede una rete di sicurezza per essere sintetizzato.</p>
<p>Pertanto, l’oracolo è una parte fondamentale del puzzle di Synthetix. In breve, gli oracoli blockchain sono il collegamento tra i contratti intelligenti e il mondo reale: sono i ponti tra TradFi e la piattaforma, così come tra il mondo reale e gli asset sintetici creati nell’ecosistema digitale. Ad esempio, se il prezzo dell’argento aumenta o diminuisce nel mercato tradizionale, l’oracolo DeFi trasmetterà queste informazioni alla rete Synthetix; di conseguenza, il prezzo di sSilver scenderà anch’esso per adattarsi alle fluttuazioni del mercato.</p>
<h2 id="h2-moneta20SNX104579"><a name="moneta SNX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>moneta SNX</h2><p>Durante l’offerta iniziale di monete (ICO) di SNX, sono stati raccolti un totale di 30 milioni di dollari e sono stati emessi 100 milioni di token. All’epoca, SNX era conosciuto come Havven, ma attraverso un rinominamento è stato cambiato in Synthetix, e ora la sua fornitura è limitata, per un totale di 255 milioni di monete.</p>
<p>Intorno a marzo di ogni anno, l’offerta aumenta. A marzo dello scorso anno, l’offerta totale di SNX è passata da 1,75 milioni a 2,12 miliardi, con un aumento del 21%. A marzo dello scorso anno, cioè nel 2022, il token SNX ha raggiunto i 2,31 miliardi—un aumento del 9% su base annua. Marzo 2024 sarà l’ultimo aumento dell’offerta della rete, che raggiungerà infine i 2,55 miliardi.</p>
<p>Oltre alla sua economia dei token, il token SNX ha due funzioni molto distinte: innanzitutto, è un token obbligatorio necessario per creare Synth. Per farlo, i token SNX devono essere collateralizzati a un rapporto del 750%, oppure staked come asset partecipativo sulla piattaforma per stabilizzare il valore dei Synth. In secondo luogo, viene utilizzato come meccanismo di governance per Synthetix DAO (Organizzazione Autonoma Decentralizzata). In quanto token di governance, i possessori di SNX possono votare su proposte di miglioramento del progetto e partecipare alle proposte di aggiornamento quando necessario.</p>
<h2 id="h2-Come20acquistare20SNX14685"><a name="Come acquistare SNX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare SNX</h2><p>Il token SNX di Synthetix può essere acquistato su Gate. I servizi di trading di Gate includono depositi in contante, depositi in criptovalute, transazioni con carta di credito e trading P2P, tra gli altri.</p>
<p>Devi solo crearne uno sull’exchange Gate. <a href="https://www.gate.com/signup" target="_blank"><em>Account Gate</em></a> Poi vai nell’area di trading e seleziona <a href="https://www.gate.com/trade/BTC_USDT?ch=ann974" target="_blank"><em>Trading Spot</em></a> Puoi effettuare un acquisto. Dopo essere entrato nella pagina di trading spot, cerca Synthetix o SNX nella casella di ricerca in alto a sinistra per visualizzare quali coppie di trading sono disponibili per il trading—attualmente, la coppia di trading più popolare è SNX/USDT.</p>
<p>Se il tuo account ha già i fondi appropriati per le coppie di trading, puoi effettuare un ordine immediatamente!</p>
<h2 id="h2-Come20conservare20SNX472406"><a name="Come conservare SNX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come conservare SNX</h2><p>Una volta acquistati gli asset su Gate, puoi immediatamente godere di servizi di gestione patrimoniale premium, a cui puoi accedere tramite il menu del wallet nell’angolo in alto a destra della homepage ufficiale. Basta andare su <a href="https://www.gate.com/myaccount/myfunds" target="_blank"><em>Panoramica dei fondi</em></a> Nella pagina, seleziona l’account per gli asset che desideri visualizzare.</p>
<h2 id="h2-Come20effettuare20lo20staking20di20SNX240897"><a name="Come effettuare lo staking di SNX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come effettuare lo staking di SNX</h2><p>Gate offre soluzioni di staking per migliaia di Crypto Asset, incluso lo staking di SNX. Se desideri effettuare lo staking di Synthetix, per favore vai alla barra del menu in alto sul sito ufficiale e clicca sul menu Gate Finance, poi clicca su Wealth Management. <a href="https://www.gate.com/hodl?ch=ann974" target="_blank"><em>Tesoro di Gestione Patrimoniale</em></a> Dopo la pagina, fai clic sulla categoria risparmi per vedere quali soluzioni Synthetix sono attualmente disponibili - la piattaforma Gate potrebbe aggiungere nuove opzioni tra cui scegliere in qualsiasi momento. Allo stesso tempo, puoi anche navigare e visualizzare qualsiasi altro asset investibile sulla piattaforma in qualsiasi momento. Sentiti libero di navigare e 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 totale o parziale 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="12">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>