R2F0ZS5pbyBBTUEgY29uIEh1cnJpY2FuZVN3YXAgLSBJbCBwcmltbyBERVggZGkgbGlxdWlkaXTDoCBDcm9zcy1DaGFpbiBzdSBBdmFsYW5jaGU=

<p><img src="https://gimg2.gateimg.com/image/article/16899267011.jpeg" alt=""><br><strong>Ora: 25 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Symington W. Smith, Fondatore di HurricaneSwap in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di Gate.io Exchange</a>.</strong><br><strong>Sito ufficiale: <a href="https://hurricaneswap.com/#/" rel="nofollow noopener noreferrer" target="_blank">https://hurricaneswap.com/#/</a></strong><br><strong>Twitter: <a href="https://twitter.com/HurricaneSwap" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HurricaneSwap</a></strong><br><strong>Segui HurricaneSwap su <a href="https://twitter.com/HurricaneSwap" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/HurricaneSwap" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16899268592.jpg" alt=""><br><strong>Symington W. Smith — Fondatore di HurricaneSwap</strong></p>
<h2 id="h2-QampA20da20Gateio958"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Ciao20Symington20Prima20di20procedere20puoi20fornire20una20breve20autopresentazione20per20la20comunit282167"><a name="Q1: Ciao Symington. Prima di procedere, puoi fornire una breve auto-presentazione per la comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Ciao Symington. Prima di procedere, puoi fornire una breve auto-presentazione per la comunità?</h3><p><strong>Symington</strong> Ciao a tutti. Sono Symington, il fondatore di HurricaneSwap.</p>
<p>È un piacere condividere con voi le ultime notizie su HurricaneSwap.</p>
<h3 id="h3-Q220Qual2020esattamente20il20tuo20progetto20e20puoi20dirci20di20pi20sulla20tua20visione108605"><a name="Q2: Qual è esattamente il tuo progetto e puoi dirci di più sulla tua visione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è esattamente il tuo progetto e puoi dirci di più sulla tua visione?</h3><p><strong>Symington</strong>: Abbiamo una definizione ufficiale di HurricaneSwap:</p>
<p>Il primo DEX di liquidità cross-chain basato su <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>.<br><img src="https://gimg2.gateimg.com/image/article/16899269023.jpg" alt=""><br>Più specificamente, HurricaneSwap è un DEX di liquidità cross-chain con un innovativo meccanismo LP-Bridge (Roke Protocol), che consente agli utenti di scambiare asset popolari di altre catene senza abbandonare Avalanche.</p>
<h3 id="h3-Q320Molto20buono20Presumo20che20ci20siano20molteplici20approcci20per20risolvere20il20problema20della20liquidit20crosschain20Perch20larchitettura20attuale20di20HurricaneSwap2020la20soluzione20ottimale149250"><a name="Q3: Molto buono! Presumo che ci siano molteplici approcci per risolvere il problema della liquidità cross-chain. Perché l’architettura attuale di HurricaneSwap è la soluzione ottimale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Molto buono! Presumo che ci siano molteplici approcci per risolvere il problema della liquidità cross-chain. Perché l’architettura attuale di HurricaneSwap è la soluzione ottimale?</h3><p><strong>Symington</strong>: Sono d’accordo con te, ci sono molte soluzioni di liquidità cross-chain, come il ponte cross-chain.</p>
<p>Tuttavia, penso che il ponte cross-chain sia stato progettato per essere uno strumento a bassa frequenza, come WBTC o RenBTC.</p>
<p>Tecnicamente, è abbastanza difficile sviluppare un ponte cross-chain.</p>
<p>Inoltre è difficile guadagnare profitto come un ponte cross-chain.</p>
<p>Nel caso di maggior parte degli scambi cross-chain, in realtà sviluppano un ponte cross-chain e poi scoprono che è difficile ottenere un profitto, quindi decidono di farlo diventare uno scambio.</p>
<p>Tuttavia, sanno appena di trading, quindi non possono offrire agli utenti un’esperienza di trading soddisfacente.</p>
<p>HurricaneSwap è diverso. Siamo progettati con vere esigenze e pensiamo sempre dal lato dell’utente.</p>
<p>Sei il benvenuto a provare il nostro prodotto: <a href="https://hurricaneswap.com/#/" rel="nofollow noopener noreferrer" target="_blank">https://hurricaneswap.com/#/</a></p>
<h3 id="h3-Q420Molto20interessante20Puoi20per20favore20dirci20di20pi20sulla20tokenomica20del20progetto327496"><a name="Q4: Molto interessante! Puoi per favore dirci di più sulla tokenomica del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Molto interessante! Puoi per favore dirci di più sulla tokenomica del progetto?</h3><p><strong>Symington</strong>: Certamente.</p>
<p>Qui puoi vedere il tokenomics di HCT.</p>
<p>Come token nativo di HurricaneSwap, $HCT rappresenta molti diritti dei detentori.</p>
<p>Prima di tutto, il diritto di voto.</p>
<p>HurricaneSwap è un progetto guidato dalla comunità, dopo il lancio della mainnet, ci si aspetta che i detentori di $HCT partecipino alla governance del progetto, inclusi l’elenco dei token, il piano di marketing, lo sviluppo della comunità e così via.</p>
<p>Ancora più importante, gli utenti devono bruciare $HCT per votare.<br><img src="https://gimg2.gateimg.com/image/article/16899269174.jpg" alt=""><br>Sulla base dell’esperienza delle CEX, quel tipo di attività di quotazione potrebbe bruciare centinaia di milioni di token. Immagina.</p>
<h3 id="h3-Q520Secondo20te20in20che20modo20HurricaneSwap20beneficia20dellintero20ecosistema20Avalanche363659"><a name="Q5: Secondo te, in che modo HurricaneSwap beneficia dell’intero ecosistema Avalanche?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Secondo te, in che modo HurricaneSwap beneficia dell’intero ecosistema Avalanche?</h3><p><strong>Symington</strong>: Questa è una grande domanda.</p>
<p>In realtà, beneficiare di <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> è la nostra prima priorità.</p>
<p>Come DEX cross-chain, miriamo a portare più asset di valore su Avalanche.</p>
<p>Questo è ciò di cui Avalanche ha più bisogno in questo momento.</p>
<p>Inoltre, sono stato in Cina per molti anni, quindi sono abbastanza risorsivo in Cina e anche in altri paesi dell’Asia.</p>
<p>Posso vedere che Avalanche attribuisce grande importanza all’intero mercato asiatico, quindi spero di poterli aiutare a espandersi in nuovi mercati in Asia. Far conoscere Avalanche a più persone e farne parte.</p>
<h3 id="h3-Q620Sono20passate20due20settimane20dal20lancio20della20mainnet20come20sta20andando20tutto354848"><a name="Q6: Sono passate due settimane dal lancio della mainnet, come sta andando tutto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Sono passate due settimane dal lancio della mainnet, come sta andando tutto?</h3><p><strong>Symington</strong>: Le cose stanno andando piuttosto bene di recente.</p>
<p>Abbiamo lanciato HurricaneSwap V1 il 10 ottobre, nel frattempo $HCT è stato quotato su MEXC Global, MDEX, ZB e HurricaneSwap.</p>
<p>Il giorno dell’apertura, il prezzo più alto di $HCT ha raggiunto 0,49USDT, che è 16 volte più alto del prezzo di offerta pubblica di 0,03USDT.</p>
<p>Al momento, la mainnet di HurricaneSwap è stata lanciata con successo da due settimane e funziona senza problemi. Il numero degli utenti ha superato i 50.000 e sono stati aperti 17 LP.</p>
<p>La funzione di transazione cross-chain è stata anche sotto test su HurricaneSwap Testnet V2. Finora, 4940 indirizzi hanno partecipato ai test interattivi e sono state completate con successo 8886 interazioni contrattuali.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>