R2F0ZS5pbyBBTUEgbWV0IEh1cnJpY2FuZVN3YXAgLSBkZSBlZXJzdGUgQ3Jvc3MtQ2hhaW4gTGlxdWlkaXRlaXQgREVYIG9wIEF2YWxhbmNoZQ==

<p><img src="https://gimg2.gateimg.com/image/article/16899267011.jpeg" alt=""><br><strong>Tijd: 25 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hosted een AMA (Ask-Me-Anything) sessie met Symington W. Smith, Oprichter van HurricaneSwap in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <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>Volg HurricaneSwap op <a href="https://twitter.com/HurricaneSwap" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/HurricaneSwap" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16899268592.jpg" alt=""><br><strong>Symington W. Smith — Oprichter van HurricaneSwap</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio708078"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Hallo20Symington20Voordat20we20verder20gaan20kunt20u20alstublieft20een20korte20zelfintroductie20geven20aan20de20gemeenschap512817"><a name="Q1: Hallo Symington. Voordat we verder gaan, kunt u alstublieft een korte zelfintroductie geven aan de gemeenschap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Hallo Symington. Voordat we verder gaan, kunt u alstublieft een korte zelfintroductie geven aan de gemeenschap?</h3><p><strong>Symington</strong>: Hallo allemaal. Ik ben Symington, de oprichter van HurricaneSwap.</p>
<p>Het is een plezier om het laatste nieuws over HurricaneSwap met jullie te delen.</p>
<h3 id="h3-Q220Wat20is20jouw20project20precies20en20kun20je20ons20meer20vertellen20over20jouw20visie135600"><a name="Q2: Wat is jouw project precies en kun je ons meer vertellen over jouw visie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is jouw project precies en kun je ons meer vertellen over jouw visie?</h3><p><strong>Symington</strong>: We hebben een officiële definitie van HurricaneSwap:</p>
<p>De eerste Cross-Chain Liquidity DEX gebaseerd op <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>Meer specifiek is HurricaneSwap een cross-chain liquiditeit DEX met een innovatief LP-Bridge mechanisme (Roke Protocol), waarmee gebruikers populaire activa van andere ketens kunnen verhandelen zonder <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> te verlaten.</p>
<h3 id="h3-Q320Heel20leuk20Ik20neem20aan20dat20er20meerdere20benaderingen20zijn20om20het20probleem20van20crosschain20liquiditeit20op20te20lossen20Waarom20is20de20huidige20architectuur20van20HurricaneSwap20de20optimale20oplossing508409"><a name="Q3: Heel leuk! Ik neem aan dat er meerdere benaderingen zijn om het probleem van cross-chain liquiditeit op te lossen. Waarom is de huidige architectuur van HurricaneSwap de optimale oplossing?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Heel leuk! Ik neem aan dat er meerdere benaderingen zijn om het probleem van cross-chain liquiditeit op te lossen. Waarom is de huidige architectuur van HurricaneSwap de optimale oplossing?</h3><p><strong>Symington</strong>: Ik ben het met je eens, er zijn veel oplossingen voor cross-chain liquiditeit, zoals cross-chain bridge.</p>
<p>Ik denk echter dat de cross-chain bridge is ontworpen om een tool met lage frequentie te zijn, zoals WBTC of RenBTC.</p>
<p>Technisch gezien is het behoorlijk moeilijk om een cross-chain brug te ontwikkelen.</p>
<p>Ook is het moeilijk om winst te maken als een cross-chain brug.</p>
<p>Bij de meeste cross-chain swaps ontwikkelen ze eigenlijk een cross-chain bridge en komen er dan achter dat het moeilijk is om winst te maken, dus besluiten ze er een swap van te maken.</p>
<p>Ze weten echter nauwelijks iets van handelen, dus ze kunnen gebruikers geen goede handelservaring bieden.</p>
<p>HurricaneSwap is anders. We zijn ontworpen met echte behoeften en denken altijd vanuit het perspectief van de gebruiker.</p>
<p>Je bent van harte welkom om ons product te proberen: <a href="https://hurricaneswap.com/#/" rel="nofollow noopener noreferrer" target="_blank">https://hurricaneswap.com/#/</a></p>
<h3 id="h3-Q420Dat20is20best20interessant20Kun20je20ons20alsjeblieft20meer20vertellen20over20de20tokenomics20achter20het20project510943"><a name="Q4: Dat is best interessant! Kun je ons alsjeblieft meer vertellen over de tokenomics achter het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Dat is best interessant! Kun je ons alsjeblieft meer vertellen over de tokenomics achter het project?</h3><p><strong>Symington</strong>: Zeker.</p>
<p>Hier kunt u de tokenomics van HCT zien.</p>
<p>Als de inheemse token van HurricaneSwap vertegenwoordigt $HCT de vele rechten van houders.</p>
<p>Allereerst het recht om te stemmen.</p>
<p>HurricaneSwap is een door de community gedreven project. Na de lancering van het mainnet wordt verwacht dat $HCT-houders deelnemen aan projectgovernance, inclusief tokennotering, marketingplan, gemeenschapsontwikkeling enzovoort.</p>
<p>Belangrijker nog, gebruikers moeten $HCT verbranden om te stemmen.<br><img src="https://gimg2.gateimg.com/image/article/16899269174.jpg" alt=""><br>Op basis van de ervaring van CEXs zou dat soort noteringsactiviteit honderden miljoenen tokens kunnen verbranden. Stel je dat eens voor.</p>
<h3 id="h3-Q520Naar20jouw20mening20hoe20profiteert20HurricaneSwap20van20het20hele20Avalancheecosysteem855200"><a name="Q5: Naar jouw mening, hoe profiteert HurricaneSwap van het hele Avalanche-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Naar jouw mening, hoe profiteert HurricaneSwap van het hele Avalanche-ecosysteem?</h3><p><strong>Symington</strong>: Dat is een geweldige vraag.</p>
<p>Eigenlijk is het ten goede komen van Avalanche onze eerste prioriteit.</p>
<p>Als een cross-chain DEX streven we ernaar om meer waardevolle activa naar Avalanche te brengen.</p>
<p>Dat is wat Avalanche op dit moment het meest nodig heeft.</p>
<p>Bovendien ben ik al vele jaren in China, dus ik ben behoorlijk vindingrijk in China en ook in andere Aziatische landen.</p>
<p>Ik zie dat Avalanche veel belang hecht aan de hele Aziatische markt, dus ik hoop dat ik ze kan helpen uit te breiden naar nieuwe markten in Azië. Laat meer mensen weten over Avalanche en er deel van uitmaken.</p>
<h3 id="h3-Q620Het20is20nu20twee20weken20geleden20sinds20jullie20de20mainnet20hebben20gelanceerd20hoe20gaat20alles810559"><a name="Q6: Het is nu twee weken geleden sinds jullie de mainnet hebben gelanceerd, hoe gaat alles?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Het is nu twee weken geleden sinds jullie de mainnet hebben gelanceerd, hoe gaat alles?</h3><p><strong>Symington</strong>: Dingen gaan de laatste tijd behoorlijk goed.</p>
<p>We lanceerden HurricaneSwap V1 op 10 oktober, terwijl $HCT werd vermeld op MEXC Global, MDEX, ZB en HurricaneSwap.</p>
<p>Op de openingsdag bereikte de hoogste prijs van $HCT 0,49USDT - dat is 16 keer hoger dan de openbare aanbiedingsprijs van 0,03USDT.</p>
<p>Op dit moment is HurricaneSwap mainnet al twee weken succesvol online en draait soepel. Het aantal gebruikers heeft de 50.000 overschreden en er zijn 17 LP’s geopend.</p>
<p>De cross-chain transactiefunctie is ook getest op HurricaneSwap Testnet V2. Tot nu toe hebben 4940 adressen deelgenomen aan interactieve tests en zijn er 8886 contractinteracties succesvol voltooid.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>