R2F0ZS5pbyBBTUEgY29uIENoYWlucG9ydC1UaSBjb25zZW50ZSBkaSBzYWx0YXJlIHRyYSBsZSBjYXRlbmUgY29uIHVuIGNsaWM=

<p><img src="https://gimg2.gateimg.com/image/article/1675754748IMG_20230207_133609.jpg" alt=""><br><strong>Ora: 30 settembre 2022, 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 il CMO di Chainport, Maximiliano Stochyk in il <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: <a href="http://chainport.io/" rel="nofollow noopener noreferrer" target="_blank">http://chainport.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/chain_port</a></strong><br><strong>Segui Chainport su <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/chainport" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16757549291.jpg" alt=""><br><strong>Maximiliano Stochyk — CMO di Chainport</strong></p>
<h2 id="h2-QampA20da20Gateio196756"><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-Q120Puoi20presentarti20alla20nostra20comunit30489"><a name="Q1: Puoi presentarti alla nostra comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti alla nostra comunità?</h3><p><strong>Maximiliano</strong>: Ciao sono Maximiliano, Responsabile Marketing presso ChainPort, ho iniziato a investire in Crypto nel 2014.</p>
<h3 id="h3-Q220Puoi20dirci20brevemente20cosa2020ChainPort20in203520frasi793256"><a name="Q2: Puoi dirci brevemente cosa è ChainPort in 3-5 frasi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi dirci brevemente cosa è ChainPort in 3-5 frasi?</h3><p><strong>Maximiliano</strong>: ChainPort è un ponte blockchain di prossima generazione ad alta sicurezza che ti consente di passare da una catena all’altra con un clic.<br><img src="https://gimg2.gateimg.com/image/article/16757551152.png" alt=""><br>Oggi realizza la promessa di piena interoperabilità tra le blockchain e lo fa attraverso un’interfaccia semplice e sicura.</p>
<h3 id="h3-Q320Parliamo20ora20dei20traguardi20che20hai20raggiunto20finora20e20dei20tuoi20prossimi20piani491157"><a name="Q3: Parliamo ora dei traguardi che hai raggiunto finora e dei tuoi prossimi piani?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Parliamo ora dei traguardi che hai raggiunto finora e dei tuoi prossimi piani?</h3><p><strong>Maximiliano</strong>: ChainPort è uno dei ponti più grandi dello spazio con TVL su DefiLlama.com, abbiamo raggiunto molte cose fantastiche nell’ultimo anno dal nostro lancio nel giugno 2021!</p>
<p>Al momento supportiamo più di 9 catene tra cui Ethereum, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain, Avalanche, Polygon, Fuse, Fantom, Moonriver, Aurora e Dogechain!</p>
<p>Il nostro TVL si attesta intorno a $70M ma con un ATH di quasi $500M, il nostro volume è sostanziale e si attesta a più di $615M negli ultimi mesi, il che è fantastico!</p>
<p>Siamo riusciti a ottenere l’adozione e stiamo appena iniziando, grandi aggiornamenti arriveranno nei prossimi mesi, tra cui il supporto per Stablecoin, nuove catene, custode privato ChainPort e altro ancora!</p>
<h3 id="h3-Q420Puoi20spiegare20il20tuo20prodotto20e20le20sue20caratteristiche20alla20nostra20comunit132702"><a name="Q4: Puoi spiegare il tuo prodotto e le sue caratteristiche alla nostra comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi spiegare il tuo prodotto e le sue caratteristiche alla nostra comunità?</h3><p><strong>Maximiliano</strong>: La segregazione dei fondi - Siamo l’unico ponte completamente custodito nello spazio, abbiamo scoperto che questo è il modo migliore da seguire dopo aver scoperto che i ponti decentralizzati non possono essere affidati per ora a causa della tecnologia coinvolta nell’operare in modo sicuro un ponte.</p>
<p>Velocità - Siamo in grado di trasferire qualsiasi token da una catena all’altra in soli 3 minuti, siamo il ponte più veloce dello spazio.</p>
<p>Supporto umano in diretta - Offriamo supporto per tutti i progetti/comunità che utilizzano Chainport, effettivamente supporto umano in diretta, quindi se un utente ha problemi con il porting, può mettersi in contatto direttamente con noi.<br><img src="https://gimg2.gateimg.com/image/article/16757551513.png" alt=""><br>Senza autorizzazione - Non c’è bisogno di pagare per un annuncio, ottenere l’approvazione, ecc… Chiunque può venire con il proprio token e portarlo su una qualsiasi delle nostre catene supportate, gratuitamente. Solo le tasse del gas.</p>
<h3 id="h3-Q520PORTX2020qui20Puoi20dirci20di20pi20sul20tuo20token20nativo319228"><a name="Q5: PORTX è qui. Puoi dirci di più sul tuo token nativo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: PORTX è qui. Puoi dirci di più sul tuo token nativo?</h3><p><strong>Maximiliano</strong>: Sì, quindi PORTX è il nostro token nativo <a href="https://chainport.io/token" rel="nofollow noopener noreferrer" target="_blank">https://chainport.io/token</a></p>
<p>Abbiamo lanciato la settimana scorsa! Puoi ottenere PORTX su Gate.io</p>
<p>Il token di utilità nativo di ChainPort è il token PORTX, è centrale all’ecosistema e alla sostenibilità a lungo termine di ChainPort, e rappresenta un’unità di valore e un mezzo di scambio che può essere utilizzato in molti modi.</p>
<p>Invito tutti a unirsi alla nostra comunità TG per leggere le ultime notizie @chainport e <a href="https://twitter.com/chain_port" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/chain_port</a></p>
<p>Poiché siamo un ponte, saremo elencati su tutti i principali DEX su catene diverse e anche su elenchi CEX!</p>
<p>Non ne abbiamo annunciato tutti, quindi rimanete sintonizzati per i prossimi giorni!</p>
<p>Arrivano ottime notizie e puoi anche seguire il nostro canale di notizie ChainPort qui: t.me/chainport_news</p>
<h3 id="h3-Q620Quali20sono20i20principali20vantaggi20di20possedere20PORTX20a20lungo20termine830765"><a name="Q6: Quali sono i principali vantaggi di possedere PORTX a lungo termine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Quali sono i principali vantaggi di possedere PORTX a lungo termine?</h3><p><strong>Maximiliano</strong>: La distribuzione delle commissioni - Il meccanismo di commissioni di ChainPort garantisce la sostenibilità a lungo termine per un ponte tra catene. Il meccanismo trasforma essenzialmente ChainPort e il token PORTX in un ecosistema con incentivi per i detentori e i progetti crittografici. Trasformando ChainPort in un ecosistema completo, diventerà il ponte di scelta per chiunque voglia portare i token.</p>
<p>Commissione di trasferimento di base - fino al 95% convertita in PORTX</p>
<p>Ricompensa del progetto del 20% - Un incentivo continuo per i progetti che scelgono ChainPort come loro ponte ufficiale di scelta. Richiedibile in PORTX.</p>
<p>20% Ricompense di partecipazione - Per ogni porto effettuato, l’utente riceverà punti che li ricompenseranno con PORTX.</p>
<p>20% Ricompense di Referral/Affiliazione - distribuite alle parti idonee che hanno fatto riferimento al token portato, o ai porti effettuati da un modello ChainPort integrato o tramite l’API.</p>
<p>Riacquisto del 15% di PORTX - Una parte verrà utilizzata per riacquistare PORTX sul mercato. Una parte o tutto questo importo potrebbe essere utilizzato per rimuovere i token dalla liquidità (bruciandoli).</p>
<p>10% Liquidità - Aggiunta su vari DEX come liquidità permanente. Metà in PORTX e metà in stablecoin.</p>
<p>10% APY per gli stakers - Questa porzione premia gli stakers di PORTX sul contratto ufficiale del gestore delle commissioni di ChainPort.</p>
<p>Sviluppo futuro del 5% di ChainPort - verrà utilizzato per lo sviluppo futuro di ChainPort.</p>
<h3 id="h3-Q720Riguardo20alla20Roadmap20puoi20per20favore20aggiornarci20sulle20prossime20tappe20previste20per20i20prossimi20mesi403064"><a name="Q7: Riguardo alla Roadmap, puoi per favore aggiornarci sulle prossime tappe previste per i prossimi mesi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Riguardo alla Roadmap, puoi per favore aggiornarci sulle prossime tappe previste per i prossimi mesi?</h3><p><strong>Maximiliano</strong>: Stiamo lavorando su molte nuove catene. Abbiamo appena introdotto Dogechain, Aurora come EVM e avremo <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> come nostra prima catena non-evm nelle prossime settimane. Questo è un grande traguardo, dovrebbe accadere dopo il fork di Cardano!</p>
<p>Prossimamente continueremo ad aggiungere ulteriori catene EVM e non-EVM come <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e altre ancora!</p>
<p>Puoi controllare la nostra roadmap qui: <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">https://twitter.com/chain_port/</a><a href="https://twitter.com/chain_port/<a href=&quot;https://www.gate.io/trade/SNT_USDT&quot; target=&quot;_blank&quot;>Status</a>/1570093736150941697" rel="nofollow noopener noreferrer" target="_blank">Status</a>/1570093736150941697</p>
<h3 id="h3-Q820Chi20sono20i20tuoi20pi20grandi20partner20e20investitori498097"><a name="Q8: Chi sono i tuoi più grandi partner e investitori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Chi sono i tuoi più grandi partner e investitori?</h3><p><strong>Maximiliano</strong>: ChainPort ha raccolto oltre $14 milioni in round privati e pubblici, guidati da DAO Maker, Shima capital e LD Capital. Gli investitori iniziali nel progetto includono più di 50 tra i principali VC focalizzati su blockchain. Gli investitori includono ZBS Capital, Master Ventures, Double Peak, Halvings Cap, Metrix Capital, Fundamental Labs, Tribe Capital, Poolz, Kairon Labs, Maven Capital, Lucid Blue, CoinX, Ghaf Capital, Existential capital e altri.</p>
<p>Puoi trovare di più qui: <a href="https://www.chainport.io/blog/chainport-raised-14m-in-private-public-rounds-to-expand-its-cross-chain-bridge" rel="nofollow noopener noreferrer" target="_blank">https://www.chainport.io/blog/chainport-raised-14m-in-private-public-rounds-to-expand-its-cross-chain-bridge</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità di 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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>