UHJvY2Vzc28gZGkgbGlxdWlkYXppb25lIGUgY2FsY29sbyBkZWwgcHJlenpvIGRpIGxpcXVpZGF6aW9uZQ==

<p><img src="https://gimg2.gateimg.com/image/trading202505291421496218531403.png" alt="">
</p><h2 id="h2-Aggiornamento20sulla20Liquidazione202025895382"><a name="Aggiornamento sulla Liquidazione 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamento sulla Liquidazione 2025</h2><p>Entro il 2025, Gate (Gate) ha ottimizzato il suo processo di clearing attraverso i seguenti miglioramenti chiave:<br>-<br><strong>Riduci il 30% dello slippage di liquidazione</strong> Migliorando il pool di liquidità, il slippage durante il processo di liquidazione viene ridotto, migliorando l’efficienza della liquidazione.<br>-<br><strong>Notifica di avviso di regolamento di 5 secondi</strong> Prima che il regolamento sia in procinto di avvenire, il sistema invierà una notifica di avviso agli utenti 5 secondi prima, dando agli utenti più tempo per reagire.<br>-<br><strong>Opzioni di liquidazione parziale</strong> Aggiunte alcune opzioni di liquidazione che consentono agli utenti di mantenere parte delle loro posizioni quando affrontano una liquidazione, riducendo le perdite.<br>-<br><strong>Strumento di simulazione pre-accordo</strong> La piattaforma ora offre uno strumento di simulazione pre-liquidazione che consente ai trader di testare vari scenari di mercato prima di aprire posizioni, aiutandoli a comprendere in anticipo i potenziali rischi di liquidazione.<br>-<br><strong>Fondo Assicurativo Rafforzato</strong> Il fondo di assicurazione è stato potenziato, fornendo una migliore protezione contro le fluttuazioni di mercato e garantendo un meccanismo di liquidazione stabile per tutti i tipi di contratto.</p>
<h2 id="h2-Processo20di20clearing93408"><a name="Processo di clearing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Processo di clearing</h2><h3 id="h3-Processo20di20liquidazione20forzata389604"><a name="Processo di liquidazione forzata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Processo di liquidazione forzata</h3><p>Gate utilizza il prezzo di riferimento come base per determinare se liquidare la posizione di un utente. L’effetto della liquidazione forzata varia a seconda che l’utente utilizzi un margine isolato o un margine incrociato.</p>
<ul>
<li><strong>Modalità a margine incrociato con leva</strong> Quando il saldo del margine di questa posizione scende al di sotto del livello di margine di mantenimento, la posizione verrà liquidata forzatamente. Il saldo del margine include profitti e perdite non realizzati. In una modalità a doppia posizione, poiché le posizioni lunghe e corte sono indipendenti, fluttuazioni estreme del mercato possono portare alla liquidazione di entrambe separatamente.</li><li><strong>Modalità di leva a margine completo</strong> Tutto il saldo disponibile è margine. Quando il saldo disponibile e il margine della posizione attuale sono inferiori al livello di margine di mantenimento, la posizione sarà liquidata forzosamente. Il saldo del margine include il profitto e la perdita non realizzati. Nella modalità di detenzione bidirezionale, solo quando la perdita netta in entrambe le direzioni più tutto il saldo disponibile e il margine è ancora inferiore al livello di margine di mantenimento, sarà liquidata forzosamente.</li></ul>
<p><strong>Quando viene attivata una liquidazione forzata, il sistema attiverà sequenzialmente il mercato stesso, il fondo di assicurazione e il sistema automatico di riduzione delle posizioni per completare la liquidazione forzata. Il processo specifico è il seguente:</strong></p>
<ol>
<li>Se il prezzo di riferimento supera il prezzo di liquidazione, verrà avviato il processo di liquidazione.</li><li>Gli ordini non eseguiti come ordini aperti e ordini strategici verranno annullati.</li><li>Quando si piazza un ordine al prezzo di bancarotta, se il prezzo di mercato è migliore del prezzo di bancarotta, verrà eseguito prima al prezzo di mercato.</li><li>Se l’ordine viene eseguito, il processo termina.</li><li>Se il prezzo di riferimento supera il prezzo di bancarotta, verranno attivati il fondo di assicurazione e la riduzione automatica delle posizioni.</li><li>Se il prezzo di riferimento non supera il prezzo di bancarotta, la posizione verrà bloccata fino a quando l’ordine di liquidazione non verrà eseguito.</li></ol>
<p>Dopo aver attivato una liquidazione forzata, gli utenti possono fare clic sui dettagli della liquidazione forzata nella cronologia delle operazioni/storia di chiusura per visualizzare informazioni dettagliate.</p>
<h2 id="h2-Calcolo20del20Prezzo20di20Liquidazione858001"><a name="Calcolo del Prezzo di Liquidazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Calcolo del Prezzo di Liquidazione</h2><p>Quando il saldo del margine della posizione contrattuale di un utente scende al di sotto del livello di margine di mantenimento, la posizione sarà forzatamente liquidata dal sistema di trading. Dopo la liquidazione forzata, l’utente perderà tutto il margine della posizione. Nel trading di contratti reale, quando il prezzo di riferimento raggiunge il prezzo di liquidazione, verrà attivata la liquidazione forzata.</p>
<h3 id="h3-Formula20di20calcolo20del20prezzo20di20liquidazione452777"><a name="Formula di calcolo del prezzo di liquidazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Formula di calcolo del prezzo di liquidazione</h3><p>La formula di calcolo per il prezzo di liquidazione varia a seconda del tipo di contratto.</p>
<h4 id="h4-Formula20di20Calcolo20del20Prezzo20di20Liquidazione20del20Contratto20Ordinario20Long20e20DualCurrency101878"><a name="Formula di Calcolo del Prezzo di Liquidazione del Contratto Ordinario Long e Dual-Currency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Formula di Calcolo del Prezzo di Liquidazione del Contratto Ordinario Long e Dual-Currency</h4><p>Prezzo di liquidazione = (Prezzo di apertura ± Margine / Moltiplicatore del contratto / Posizione) / [1 ± (Rapporto di margine di mantenimento + Tassa)]<br>L’aggiunta o la sottrazione nella formula dipende dalla direzione del contratto; per le posizioni lunghe, sottrarre, e per le posizioni corte, aggiungere.
</p><h4 id="h4-La20formula20di20calcolo20per20il20prezzo20di20liquidazione20di20un20contratto20inverso945217"><a name="La formula di calcolo per il prezzo di liquidazione di un contratto inverso." class="reference-link"></a><span class="header-link octicon octicon-link"></span>La formula di calcolo per il prezzo di liquidazione di un contratto inverso.</h4><p>Prezzo di Liquidazione = Posizione <em>Prezzo Medio di Apertura</em>(1±Rapporto di Margine di Manutenzione±Commissione di Trading)/（Posizione±Margine*Prezzo di Apertura Medio）<br>L’addizione o la sottrazione nella formula dipende dalla direzione del contratto, se è lungo allora si aggiunge, se è corto allora si sottrae.
</p><h3 id="h3-Precauzioni305869"><a name="Precauzioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Precauzioni</h3><ul>
<li>La posizione si riferisce al numero di contratti. Puoi visualizzare il rapporto di margine di mantenimento e il moltiplicatore del contratto nelle informazioni sul contratto.</li><li>Commissione singola: 0,075%</li></ul>
<h3 id="h3-Esempio964929"><a name="Esempio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esempio</h3><p><img src="https://gimg2.gateimg.com/image/h202505291422429791809068.png" alt=""><br>Il contratto mostrato nell’immagine sopra è un contratto di posizione lunga, con un prezzo di apertura di 2399, un margine di 25,79, una posizione di 1 ETH e un rapporto di margine di mantenimento dello 0,5%.
</p><p><strong>Secondo la formula di calcolo per il prezzo di liquidazione di un contratto forward standard:</strong><br>Prezzo di Liquidazione = (Prezzo di Apertura - Margine / Moltiplicatore del Contratto / Posizione) / [1 ± (Rapporto di Margine di Manutenzione + Commissione del Taker)]
</p><p><strong>Il calcolo del prezzo di liquidazione per questo contratto è il seguente:</strong><br>Prezzo di liquidazione = (2399-25.79⁄0.01/100)/【1 -(0.5% + 0.075%)】<br>Prezzo di Liquidazione = 2373.21⁄0.99425<br>Prezzo di Liquidazione ≈ 2386.94
</p><p>Lo stesso del prezzo di liquidazione mostrato nella figura.</p>
<h2 id="h2-Conclusione988720"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Grazie alle ottimizzazioni sopra menzionate, Gate (Gate) ha reso il suo processo di compensazione più efficiente e trasparente nel 2025, offrendo una migliore protezione per i trader. I trader possono utilizzare strumenti di simulazione pre-compensazione per comprendere i rischi di compensazione in anticipo e utilizzare opzioni di compensazione parziale per ridurre le perdite. Nel frattempo, il fondo assicurativo potenziato offre anche una migliore protezione contro la volatilità del mercato.</p>
<div class="blog-details-info"><br>  <div>Autore:<strong>Team del Blog</strong><br>  <div class="info-tips"><em>Questo contenuto non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere decisioni di investimento.<br>  <div></div>Si prega di notare che Gate potrebbe limitare o vietare tutti o parte dei servizi da aree ristrette. Si prega di leggere il contratto utente per ulteriori informazioni, link:<a href="https://www.gate.io/zh/user-agreement。" data-index="1"></a><a href="https://www.gate.io/en/user-agreement" data-index="2">https://www.gate.io/it/user-agreement</a>.<br><p></p><br></em></div></div></div>