R2F0ZS5pbyBBTUEgY29uIEZsdXJyeS1JbCBGdXR1cm8gZGVsIFlpZWxkIEZhcm1pbmc=

<p><img src="https://gimg2.gateimg.com/image/article/16920806241.jpeg" alt=""><br><strong>Tempo: 3 settembre 2021, 14: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 Mike Ting, CEO di Flurry e Lawrence Wong, CTO di Flurry 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://www.flurry.finance/" rel="nofollow noopener noreferrer" target="_blank">https://www.flurry.finance/</a></strong><br><strong>Telegram: <a href="https://t.me/FlurryFinance_Official" rel="nofollow noopener noreferrer" target="_blank">https://t.me/FlurryFinance_Official</a></strong><br><strong>Segui Flurry su <a href="https://t.me/FlurryFinance_Official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/vKtW89Z3j7" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospiti</strong><img src="https://gimg2.gateimg.com/image/article/16920808212.png" alt=""><br><strong>Mike Ting - CEO di Flurry</strong><img src="https://gimg2.gateimg.com/image/article/16920808403.png" alt=""><br><strong>Lawrence Wong — CTO di Flurry</strong></p>
<h2 id="h2-QampA20da20Gateio367421"><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-Q120Ok20quindi20prima20di20tutto20potresti20spiegarci20Cos20Flurry20Finance487776"><a name="Q1: Ok, quindi prima di tutto potresti spiegarci… Cos’è Flurry Finance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Ok, quindi prima di tutto potresti spiegarci… Cos’è Flurry Finance?</h3><p><strong>Mike</strong>: Flurry si impegna per migliorare l’usabilità dei prodotti DeFi. Nonostante le velocità abbaglianti dell’innovazione nello spazio DeFi, i progressi della tecnologia spesso superano di gran lunga gli altrettanto cruciali miglioramenti dell’esperienza utente, con conseguenti barriere all’ingresso e ostacoli all’adozione. Il nostro team di FLURRY ritiene che le opportunità di investimento NON debbano essere riservate solo agli appassionati di criptovalute esperti di tecnologia ma a tutti.</p>
<p>In questo viaggio per rendere le operazioni DeFi user-friendly e accessibili per tutti, introduciamo i rhoTokens. Lo chiamiamo rhoToken perché rho è un alfabeto greco che rappresenta il tasso di interesse. Si tratta di un token cross-chain che utilizzerà le stablecoin sottostanti per partecipare continuamente al yield farming con commissioni più basse e rischi diversificati. Automatizziamo l’ingrato compito di bloccare/sbloccare e passare da e verso i prodotti DeFi su diverse catene per generare yield.</p>
<p>Molto importante, rhoToken è ancorato 1:1 alla stablecoin di supporto e quindi può fungere da mezzo di scambio. In altre parole, niente più blocco!</p>
<h3 id="h3-Q220Ma20ci20sono20altre20offerte20In20cosa20differisce20da20ci20che20c20sul20mercato272451"><a name="Q2: Ma ci sono altre offerte… In cosa differisce da ciò che c’è sul mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ma ci sono altre offerte… In cosa differisce da ciò che c’è sul mercato?</h3><p><strong>Mike</strong> Una delle caratteristiche più significative di Flurry è il suo meccanismo di Rebasing. Flurry ha un meccanismo di distribuzione degli interessi diverso dagli aggregatori di rendimento esistenti. Il rendimento generato in Flurry viene distribuito attraverso l’aumento dell’offerta di rhoTokens.</p>
<p>Con un valore variabile, i token di deposito non possono essere utilizzati come mezzo di scambio e quindi i tuoi fondi sono bloccati mentre guadagni interessi. Ma in Flurry, 1 rhoUSDC è sempre ancorato e supportato 1:1 dall’USDC sottostante e quindi i rhoToken possono essere spesi allo stesso modo delle stablecoin. In altre parole, i rhoToken possono fungere da mezzo di scambio e i proprietari non hanno bisogno di sbloccare fondi prima di spenderli.</p>
<p>Lawrence: Oltre al meccanismo di ribasatura, un’altra caratteristica significativa di Flurry è l’interoperabilità tra le catene.</p>
<p>Gli aggregatori di rendimento attuali sono limitati a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I prodotti basati su Gatechain lavorano su una singola catena, mentre Flurry mira a lavorare trasversalmente per cercare il miglior rendimento dopo i costi su catene diverse.</p>
<p>Pensaci. I proprietari di stablecoin <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> possono guadagnare interessi su un’altra catena come Matic senza preoccuparsi di tutti i problemi di trasferimento della loro stablecoin attraverso ponti e del complicato processo di conio / riscatto. Tutto ciò che devono fare è convertire la loro stablecoin in rhoTokens. È super semplice e conveniente da usare.</p>
<h3 id="h3-Q320Ora20diteci20come20farebbero20gli20utenti20che20detengono20rhoTokens20su20Ethereum20a20raccogliere20rendimenti20da20Aave20su20Matic20o20su20altre20catene685526"><a name="Q3: Ora diteci, come farebbero gli utenti che detengono rhoTokens su Ethereum a raccogliere rendimenti da Aave su Matic o su altre catene?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ora diteci, come farebbero gli utenti che detengono rhoTokens su Ethereum a raccogliere rendimenti da <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> su Matic o su altre catene?</h3><p><strong>Lawrence</strong>: Abbiamo due token: rhoTokens e Flurry Tokens.</p>
<p>rhoToken è la stablecoin cross chain con la capacità di yield farming continuo. I proprietari di rhoToken godono della flessibilità, stabilità e reddito passivo di rhoToken.</p>
<p>Il token Flurry è il nostro token di governance. I proprietari di token Flurry avranno il diritto di voto sulle strategie di generazione di rendimento aggiunta / rimozione a lungo termine. I proprietari di token Flurry possono anche scommettere per godere del reddito della commissione di gestione generato dal protocollo Flurry.</p>
<p>Ora lasciami spiegare come funziona l’interessante guadagno sul RhoToken.</p>
<p>Supponiamo che distribuiamo gli utenti di stablecoin in <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> su MATIC.</p>
<p>Quando gli interessi vengono generati, il rhoToken verrà “ribasato”. Questo avviene emettendo più rhoToken per riflettere il valore apprezzato delle stable coin detenute sotto la gestione del protocollo.</p>
<p>L’offerta globale di rhoTokens aumenta e quindi usiamo il termine ‘rebase’ per rappresentare il ricalcolo di una valuta.<br><img src="https://gimg2.gateimg.com/image/article/16920808554.png" alt=""><br>Utilizziamo i ponti (fx-portal) tra la catena MATIC e Ethereum per sincronizzare gli stati dei contratti intelligenti e ciò ricalibra efficacemente l’offerta di rhoTokens anche sulla rete Ethereum.<br><img src="https://gimg2.gateimg.com/image/article/16920808855.png" alt=""><br>Ogni detentore di rhoToken riceverà una quantità maggiore di rhoToken in base alla sua quota del totale in circolazione, e quindi vedrà aumentare il saldo del suo rhoToken nel portafoglio.</p>
<h3 id="h3-Q420E20per20concludere20prima20di20passare20alle20domande20del20nostro20pubblico20qual2020stata20lultima20novit20per20voi20e20dove20state20andando20ora391429"><a name="Q4: E per concludere prima di passare alle domande del nostro pubblico… qual è stata l’ultima novità per voi e dove state andando ora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E per concludere prima di passare alle domande del nostro pubblico… qual è stata l’ultima novità per voi e dove state andando ora?</h3><p><strong>Mike</strong>: Le ultime notizie di Flurry Finance riguardano sicuramente la vendita pubblica dei token FLURRY.</p>
<p>Siamo entusiasti di avere il lancio di Startup IEO su Gate.io nella prossima settimana il 5 settembre.</p>
<p>La registrazione inizia dalle 8:00 UTC al 6 settembre, 8:00 UTC. Dai un’occhiata alla nostra pagina su medium e naturalmente anche all’annuncio di Gate. <a href="https://medium.com/flurry-finance/flurry-startup-ieo-launched-on-gate-io-8074a51bebfb" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/flurry-finance/flurry-startup-ieo-lanciato-su-gate-io-8074a51bebfb</a> )</p>
<p>FLURRY sarà attivo per il trading su <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, Pancake &amp; Gate.io il 6 settembre!</p>
<p>Oltre a ciò, abbiamo appena annunciato una nuova collaborazione con Kyber Network, garantendo l’offerta e la domanda sufficienti dal pool di liquidità di KyberDMM: <a href="https://coinmarketcap.com/headlines/news/After-Polygon-partnership-Flurry-Finance-joins-hands-with-Kyber-Network-to-optimize-yield-farming/" rel="nofollow noopener noreferrer" target="_blank">https://coinmarketcap.com/headlines/news/After-Polygon-partnership-Flurry-Finance-joins-hands-with-Kyber-Network-to-optimize-yield-farming/</a></p>
<p>Inoltre la partnership con <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> - dove il protocollo Flurry sarà in grado di automatizzare il farming di rendimento sui prodotti DeFi su Matic: <a href="https://cointelegraph.com/press-releases/flurry-finance-partners-with-" rel="nofollow noopener noreferrer" target="_blank">https://cointelegraph.com/press-releases/flurry-finance-partners-with-</a> <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>-per-il-farming-di-rendimento-ottimizzato</p>
<p>Nel frattempo, il nostro testnet è stato lanciato su <a href="https://testapp.flurry.finance/" rel="nofollow noopener noreferrer" target="_blank">https://testapp.flurry.finance/</a> per gli utenti interessati ad avere un’anteprima dell’uso di rhoTokens e del token Flurry. I tassi APR vengono utilizzati nella rete testnet. Come ha già menzionato Lawrence, lanceremo una versione aggiornata della testnet prima di lanciare il prodotto.</p>
<p>Per quanto riguarda la nostra comunità, abbiamo costruito con successo oltre 50.000 gruppi comunitari Flurry Finance (Ufficiale) a <a href="https://t.me/FlurryFinance_Official" rel="nofollow noopener noreferrer" target="_blank">https://t.me/FlurryFinance_Official</a> Quello che abbiamo previsto, ma ci siamo sentiti piuttosto impotenti è la parte in cui vediamo gli truffatori usare la nostra identità per cercare fondi, mentre facciamo anche noi la pattuglia, avvertendo le comunità di questa notizia frustrante di “nuovi falsi gruppi” o “nuova falsa identità”, ogni giorno.</p>
<p>Speriamo di portare i beni alla comunità, e ciò mi ricorda, il nostro amministratore della comunità non ti manderà mai un messaggio diretto, in nessun modo, per favore fai attenzione! Tutte le date importanti sono state pubblicate anche nella nostra sessione IDO di medium, controlla i dettagli da lì: <a href="https://medium.com/flurry-finance/ido/home" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/flurry-finance/ido/home</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community 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. Il ripostaggio dell'articolo sarà consentito a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>