R2F0ZS5pbyBBTUEgY29uIFJ1YmljIC0gVW4gYWdncmVnYXRvcmUgZGkgdGVjbm9sb2dpYSBjcm9zcy1jaGFpbiBwZXIgdXRlbnRpICsgU3RydW1lbnRpIHBlciBkQXBwcw==

<p><img src="https://gimg2.gateimg.com/image/article/16895806151.jpg" alt=""><br><strong>Ora: 1 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 Collin O’Brien, responsabile marketing di Rubic nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://rubic.exchange/" rel="nofollow noopener noreferrer" target="_blank">https://rubic.exchange/</a></strong><br><strong>Twitter: <a href="https://twitter.com/CryptoRubic" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/CryptoRubic</a></strong><br><strong>Segui Rubic su <a href="https://twitter.com/CryptoRubic" rel="nofollow noopener noreferrer" target="_blank">Cinguettare</a> e <a href="https://t.me/cryptorubic_chat" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16895808072.jpeg" alt=""><br><strong>Collin O’Brien — Marketing Manager di Rubic</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio201960"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Collin20potresti20spiegare20alla20comunit20cos20Rubic20e20quali20sono20i20tuoi20obiettivi825197"><a name="Q1: Collin, potresti spiegare alla comunità cos’è Rubic e quali sono i tuoi obiettivi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Collin, potresti spiegare alla comunità cos’è Rubic e quali sono i tuoi obiettivi?</h3><p><strong>Collin</strong>: Rubic è uno scambio decentralizzato multi-chain. Rubic offre una piattaforma di trading per gli utenti per scambiare i loro asset digitali mantenendo sempre il controllo dei propri asset e ricevendo sempre i migliori tassi sui loro scambi.</p>
<p>Ci specializziamo in scambi cross-chain e aggregazione DEX. Significa che offriamo agli utenti la possibilità di scambiare token tra reti, in modo molto facile e intuitivo. Inoltre, agli utenti che effettuano uno scambio all’interno di una rete verranno presentate più opzioni di prezzo per i loro scambi, considerando la liquidità e le commissioni di gas.</p>
<p>Vediamo ciò che stiamo cercando di fare come qualcosa di simile a ciò che Amazon e Alibaba hanno fatto per l’e-commerce. Stiamo consolidando DeFi in una piattaforma facile da usare per consentire ai nuovi utenti di unirsi a questa nuova rivoluzione finanziaria.</p>
<p>Il nostro obiettivo è collegare ogni rete blockchain insieme per un trasferimento fluido di valore tra le reti. Abbiamo intenzione di integrare tutte le principali AMM su tutte le reti e rendere tutto interoperabile.</p>
<p>Il nostro obiettivo è diventare un nome familiare a livello globale quando si tratta di scambiare criptovalute.</p>
<h3 id="h3-Q220Puoi20dirci20chi20sono20i20fondatori20e20il20resto20del20team5592"><a name="Q2: Puoi dirci chi sono i fondatori e il resto del team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi dirci chi sono i fondatori e il resto del team?</h3><p><strong>Collin</strong> Rubic è stata fondata da Vladimir Tikhomirov e Alexandra Korneva nel settembre 2020.</p>
<p>Hanno anche creato e lavorato su MyWish, un altro progetto criptato responsabile della generazione di contratti intelligenti e della creazione di token per reti come BSC, <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a> e altri.</p>
<p>Vladimir Tikhomirov ha un dottorato in Informatica ed è un programmatore estremamente talentuoso e dotato.</p>
<p>Il nostro team è composto da sviluppatori di criptovalute, marketer e sviluppatori B2B esperti. Abbiamo oltre 20 membri nel nostro team e stiamo aggiungendo nuovi membri ogni mese. Abbiamo appena assunto altri due membri del team per gestire24⁄7supporto tecnico e clienti.</p>
<p>Abbiamo anche un team dedicato allo sviluppo aziendale. Il nostro team di marketing è composto da circa 6 persone.</p>
<p>Inoltre, abbiamo team dedicati alla programmazione Frontend e Backend.</p>
<p>Penso che la parte migliore di questa squadra sia che tutti sono pienamente convinti della visione di Vladimir per Rubic e stiamo tutti lavorando molto duramente per vederla realizzata.</p>
<h3 id="h3-Q320Detto20questo20puoi20parlare20del20problema20che20stai20risolvendo94747"><a name="Q3: Detto questo, puoi parlare del problema che stai risolvendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Detto questo, puoi parlare del problema che stai risolvendo?</h3><p><strong>Collin</strong>: Sì, assolutamente!</p>
<p>Il nostro obiettivo è risolvere il problema dell’interoperabilità. Attualmente, il processo per scambiare un asset su una blockchain con un asset su un’altra blockchain è estremamente complicato. È necessario utilizzare almeno 3 diverse piattaforme di progetto (DEX-&gt;Bridge-&gt;DEX), ma è anche necessario possedere le monete native sia della blockchain di origine che di destinazione e durante l’intero processo si pagano molte commissioni e si spreca molto tempo, e nel settore delle criptovalute, i minuti possono fare la differenza tra profitto e perdita.</p>
<p>Rimuoviamo tutta la complicazione dal trading di asset attraverso le blockchain. Gestiamo tutto sul backend in modo che l’esperienza dell’utente sia semplice e intuitiva. Se hai un token, indipendentemente dalla rete blockchain, puoi venderlo per qualsiasi altro token desideri su qualsiasi altra rete blockchain. Questo sarebbe ciò che l’utente selezionerebbe e poi ci occuperemmo di tutto dietro le quinte per effettuare lo scambio.</p>
<p>Gli investitori in RBC potranno scommettere i loro token RBC nei nostri pool di liquidità decentralizzati.</p>
<p>Le nostre piscine di liquidità vengono utilizzate per spostare il valore attraverso le reti blockchain utilizzando smart contract per bloccare &amp; sbloccare token su diverse reti al fine di inviare valore in modo efficiente (veloce &amp; economico).</p>
<p>Una volta messo in gioco nei nostri pool di liquidità decentralizzati, gli utenti riceveranno una percentuale proporzionale delle commissioni complessive raccolte per gli scambi tra reti blockchain.</p>
<p>Addebitiamo una commissione del 0,3% che viene raccolta in RBC durante il processo di contratto intelligente cross-chain.</p>
<p>Lo 0,25% è distribuito proporzionalmente a tutti i fornitori di liquidità, mentre Rubic trattiene lo 0,05% per i costi operativi.</p>
<h3 id="h3-Q420Puoi20ora20fornire20alcuni20dettagli20su20quale2020lo20scopo20del20token20Ha20una20funzionalit2020un20token20di20governance522493"><a name="Q4: Puoi ora fornire alcuni dettagli su quale è lo scopo del token? Ha una funzionalità, è un token di governance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi ora fornire alcuni dettagli su quale è lo scopo del token? Ha una funzionalità, è un token di governance?</h3><p><strong>Collin</strong>: A differenza di molti token in criptovaluta, il token RBC di Rubic ha un’utilità critica ed è di primaria importanza per il funzionamento della piattaforma stessa.</p>
<p>RBC agisce come un vaso per il trasporto di valore da una rete all’altra.</p>
<p>Utilizziamo RBC nei nostri contratti intelligenti personalizzati per spostare il valore tra le reti.<br>Token A -&gt; RBC -&gt; Blocco RBC -&gt; 0,3% di commissioni in RBC -&gt; Sblocca Wrapped RBC -&gt; Token B</p>
<p>Questo è il processo per uno swap multi-chain attraverso Rubic.</p>
<p>Per gli utenti interessati a guadagnare reddito passivo, il token RBC verrà staked nativamente nei nostri Multi-Chain Liquidity Pools nel Q4 2021. Attualmente stiamo aspettando la finalizzazione delle verifiche di terze parti per garantire che tutto sia sicuro e protetto.</p>
<p>Quando gli utenti scommettono il loro RBC nei nostri pool di liquidità, riceveranno un’allocazione proporzionale di alcune commissioni. Rubic conserva lo 0,05%, mentre gli scommettitori ricevono lo 0,25%.</p>
<p>Ancora, questo viene pagato proporzionalmente a tutti gli stakers. Maggiore è il volume di scambio multi-chain che passa attraverso la piattaforma di Rubic, maggiore sarà il reddito passivo per i detentori di RBC.</p>
<p>Il prossimo mercato di trading multi-chain supererà 1 miliardo di dollari al giorno nel 2022, e speriamo di catturare una parte significativa di quel volume di scambi giornaliero, cioè molti guadagni passivi per i detentori di token RBC.</p>
<p>Oltre a tutto ciò, RBC funge da token di governance.</p>
<p>L’offerta totale di RBC è di 124 milioni.</p>
<p>La fornitura circolante attuale di RBC è di 109 milioni.</p>
<p>Circa l’88% dei token è in circolazione. Il team possiede il 10% dei token, quindi 12,4 milioni di RBC, e vengono sbloccati gradualmente nel tempo.</p>
<p>La nostra tokenomica, a mio parere, è estremamente attraente. La maggior parte dei nostri token è in circolazione e il team detiene una piccola % rispetto alla maggior parte dei progetti.</p>
<p>Vediamo il futuro di RBC come un investimento nei nostri pool di liquidità decentralizzati per facilitare gli scambi tra blockchain. Ancora una volta, i fornitori di liquidità riceveranno una quota proporzionale delle commissioni sostenute per gli scambi tra blockchain, ossia più volume di scambi tra blockchain che scorre attraverso la nostra piattaforma, più guadagni passivi riceveranno i possessori dei nostri token.</p>
<p>Abbiamo tenuto un voto di governance all’inizio di quest’anno per determinare quale rete blockchain i nostri utenti vorrebbero che integrassimo, e hanno scelto <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>.</p>
<p>L’integrazione di <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> è nella nostra tabella di marcia per novembre!</p>
<h3 id="h3-Q520Collin20quali20tipi20di20commissioni20addebita20Rubic20Quanto20costa20effettuare20scambi20inchain20o20multichain519942"><a name="Q5: Collin, quali tipi di commissioni addebita Rubic? Quanto costa effettuare scambi in-chain o multi-chain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Collin, quali tipi di commissioni addebita Rubic? Quanto costa effettuare scambi in-chain o multi-chain?</h3><p><strong>Collin</strong>: Per quanto riguarda le commissioni, Rubic non addebita alcuna commissione per gli swap on-chain. Quindi, se stai scambiando token solo su una singola rete blockchain, Rubic non ti addebiterà mai alcuna commissione per le tue transazioni. Aggregiamo numerosi AMM per fornire ai clienti opzioni sugli swap. Qualunque AMM venga utilizzato per il loro trade, pagheranno le commissioni associate a quell’AMM.</p>
<p>L’unico momento in cui Rubic applica una commissione è durante l’elaborazione di uno scambio multi-chain.</p>
<p>La commissione addebitata da Rubic è dello standard industriale dello 0,3%. Questa viene prelevata dietro le quinte durante il processo di scambio multi-chain e viene raccolta in RBC.</p>
<p>Tuttavia, per effettuare uno scambio multi-chain, un utente tecnicamente dovrà comunque reperire liquidità da un AMM nella rete di origine e da un AMM nella rete di destinazione.</p>
<p>Rubic calcola tutte le commissioni e addebita preventivamente ai clienti nella moneta nativa della rete di origine. Quindi, se stai iniziando su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, tutte le commissioni saranno in ETH. Se stai iniziando su Binance Smart Chain, tutte le commissioni saranno in <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>.</p>
<p>Le commissioni dello 0,3% vengono raccolte e accumulate nei nostri Pool di Liquidità Multi-Chain personalizzati, dove saranno conservate fino alla distribuzione ai possessori di token in modo proporzionale. Gli utenti che posseggono token ricevono la loro quota dello 0,25%, mentre Rubic conserva lo 0,05% per i costi operativi e lo sviluppo.</p>
<p>Con un volume di trading giornaliero di tutti gli swap multi-chain previsto di superare i 5 miliardi di dollari entro la fine del 2022, riteniamo che la capacità di generare ricavi da questo modello sia enorme.</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>