R2F0ZS5pbyBBTUEgbWV0IEZsdXJyeS1EZSBUb2Vrb21zdCB2YW4gWWllbGQgRmFybWluZw==

<p><img src="https://gimg2.gateimg.com/image/article/16920806241.jpeg" alt=""><br><strong>Tijd: 3 september 2021, 14:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Mike Ting, CEO van Flurry, en Lawrence Wong, CTO van Flurry 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://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>Volg Flurry op <a href="https://t.me/FlurryFinance_Official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/vKtW89Z3j7" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16920808212.png" alt=""><br><strong>Mike Ting - CEO van Flurry</strong><img src="https://gimg2.gateimg.com/image/article/16920808403.png" alt=""><br><strong>Lawrence Wong — CTO van Flurry</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio921935"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Q120Ok20dus20eerst20kunt20u20ons20uitleggen20Wat20is20Flurry20Finance755776"><a name="Q1: Oké, dus eerst, kunt u ons uitleggen… Wat is Flurry Finance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Oké, dus eerst, kunt u ons uitleggen… Wat is Flurry Finance?</h3><p><strong>Mike</strong>: Flurry streeft ernaar de bruikbaarheid van DeFi-producten te verbeteren. Ondanks de verblindende snelheid van innovatie in de DeFi-ruimte, overtreffen de vooruitgang in technologie vaak de even cruciale verbeteringen in gebruikerservaring, wat resulteert in instapbarrières en adoptiedrempels. Ons team bij FLURRY gelooft dat beleggingsmogelijkheden NIET alleen voor tech-savvy crypto-enthousiastelingen gereserveerd moeten zijn, maar voor iedereen.</p>
<p>In deze reis om DeFi-operaties gebruiksvriendelijk en toegankelijk te maken voor iedereen, introduceren we rhoTokens. We noemen het rhoToken omdat rho een Grieks alfabet is dat de rentevoet vertegenwoordigt. Het is een cross-chain token dat de onderliggende stablecoins zal gebruiken om continu deel te nemen aan yield farming met lagere kosten en gediversifieerde risico’s. We automatiseren de tijdrovende taak van het vergrendelen/ontgrendelen en het wisselen van DeFi-producten op verschillende chains om opbrengsten te genereren.</p>
<p>Belangrijk is dat rhoToken 1:1 gekoppeld is aan de onderliggende stablecoin en dus kan fungeren als ruilmiddel. Met andere woorden, geen lock-up meer!</p>
<h3 id="h3-Q220Maar20er20zijn20andere20aanbiedingen20Hoe20verschilt20het20van20wat20er20op20de20markt20is746896"><a name="Q2: Maar er zijn andere aanbiedingen… Hoe verschilt het van wat er op de markt is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Maar er zijn andere aanbiedingen… Hoe verschilt het van wat er op de markt is?</h3><p><strong>Mike</strong>: Een van de meest belangrijke kenmerken van Flurry is zijn Rebasing Mechanisme. Flurry heeft een ander mechanisme voor het verdelen van rente dan bestaande opbrengstaggregatoren. De opbrengst gegenereerd in Flurry wordt verdeeld door de toevoer van rhoTokens te vergroten.</p>
<p>Met een veranderende waarde kunnen stortingsmunten niet worden gebruikt als ruilmiddel en dus zijn uw fondsen vastgezet terwijl ze rente verdienen. Maar in Flurry is 1 rhoUSDC altijd vastgepind en 1:1 ondersteund door de onderliggende USDC en kunnen rhoTokens dus op dezelfde manier worden uitgegeven als stablecoin. Met andere woorden, rhoTokens kunnen fungeren als ruilmiddel en eigenaars hoeven hun fondsen niet te ontgrendelen voordat ze ze uitgeven.</p>
<p>Lawrence: Afgezien van het herbasismechanisme is een andere belangrijke functie van Flurry de cross-chain interoperabiliteit.</p>
<p>Huidige opbrengst aggregators zijn beperkt tot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gebaseerde producten of werk op één keten, terwijl Flurry zich richt op het werken over ketens om de beste opbrengst na kosten op verschillende ketens te zoeken.</p>
<p>Stel je eens voor. Eigenaren van Ethereum-stablecoins kunnen rente verdienen op een andere keten, bijvoorbeeld Matic, zonder zich zorgen te hoeven maken over alle gedoe van het overzetten van hun stablecoin over ketens via bruggen en het ingewikkelde proces van het slaan/inlossen. Het enige wat ze hoeven te doen is hun stablecoin omzetten in rhoTokens. Het is super eenvoudig en handig in gebruik.</p>
<h3 id="h3-Q320Vertel20ons20nu20hoe20zouden20gebruikers20die20rhoTokens20op20Ethereum20vasthouden20opbrengsten20kunnen20genereren20uit20Aave20op20Matic20of20andere20ketens381577"><a name="Q3: Vertel ons nu, hoe zouden gebruikers die rhoTokens op Ethereum vasthouden, opbrengsten kunnen genereren uit Aave op Matic of andere ketens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Vertel ons nu, hoe zouden gebruikers die rhoTokens op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> vasthouden, opbrengsten kunnen genereren uit <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> op Matic of andere ketens?</h3><p><strong>Lawrence</strong>: We hebben twee tokens: rhoTokens en Flurry Tokens.</p>
<p>rhoToken is de cross-chain stablecoin met continue yield farming-mogelijkheid. rhoToken-eigenaars genieten van de flexibiliteit, stabiliteit en passief inkomen van rhoTokens.</p>
<p>Flurry-token is onze governance-token. Bezitters van Flurry-tokens hebben stemrecht over de toevoeging/verwijdering van yield generation-strategieën op de lange termijn. Bezitters van Flurry-tokens kunnen ook staken om te profiteren van de beheersvergoeding die wordt gegenereerd door het Flurry-protocol.</p>
<p>Laat me nu uitleggen hoe interessant het verdienen op de RhoToken werkt.</p>
<p>Laten we zeggen dat we gebruikers van stablecoin implementeren in <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> op MATIC.</p>
<p>Wanneer er rente wordt gegenereerd, wordt de rhoToken “opnieuw gefundeerd”. Dit werkt door meer rhoTokens uit te geven om de gewaardeerde waarde van de stabiele munten die onder het beheer van het protocol worden gehouden, weer te geven.</p>
<p>De wereldwijde voorraad van rhoTokens neemt toe en daarom gebruiken we de term ‘rebase’ om het herijken van een valuta weer te geven.<br><img src="https://gimg2.gateimg.com/image/article/16920808554.png" alt=""><br>We gebruiken bruggen (fx-portal) tussen het MATIC- en Ethereum-netwerk om de status van slimme contracten te synchroniseren en dit zorgt er effectief voor dat de voorraad rhoTokens op het Ethereum-netwerk opnieuw wordt gebaseerd.<br><img src="https://gimg2.gateimg.com/image/article/16920808855.png" alt=""><br>Elke rhoToken-houder krijgt meer rhoTokens toegewezen op basis van hun aandeel in de totale voorraad, en daardoor zien ze hun rhoToken-saldo toenemen in hun portemonnee.</p>
<h3 id="h3-Q420En20om20het20af20te20sluiten20voordat20we20verder20gaan20met20vragen20van20ons20publiek20wat20is20het20laatste20nieuws20voor20jullie20en20waar20gaan20jullie20nu20naartoe772950"><a name="Q4: En om het af te sluiten voordat we verder gaan met vragen van ons publiek… wat is het laatste nieuws voor jullie en waar gaan jullie nu naartoe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: En om het af te sluiten voordat we verder gaan met vragen van ons publiek… wat is het laatste nieuws voor jullie en waar gaan jullie nu naartoe?</h3><p><strong>Microfoon</strong>: Het laatste nieuws van Flurry Finance is absoluut de openbare verkoop van FLURRY-tokens.</p>
<p>We zijn verheugd om de lancering van Startup IEO op Gate.io te hebben in de komende week op 5 september.</p>
<p>Registratie begint vanaf 8 uur UTC tot 6 september, 8 uur UTC. Bekijk het op onze medium pagina en natuurlijk ook de Gate aankondiging. <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-gelanceerd-op-gate-io-8074a51bebfb</a> )</p>
<p>FLURRY zal live zijn voor handel op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, Pancake &amp; Gate.io op 6 sep!</p>
<p>Afgezien daarvan hebben we zojuist een nieuwe samenwerking aangekondigd met Kyber Network, om ervoor te zorgen dat er voldoende aanbod en vraag is vanuit de KyberDMM-liquiditeitspool: <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>Plus de samenwerking met <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> - waar het Flurry-protocol in staat zal zijn om de opbrengstlandbouw op DeFi-producten op Matic te automatiseren: <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>-voor-geoptimaliseerde-opbrengstlandbouw</p>
<p>Ondertussen is onze testnet gelanceerd op <a href="https://testapp.flurry.finance/" rel="nofollow noopener noreferrer" target="_blank">https://testapp.flurry.finance/</a> voor geïnteresseerde gebruikers om een kijkje te nemen in het gebruik van rhoTokens &amp; Flurry token. APR-tarieven worden gebruikt op het testnetwerk. Zoals Lawrence al eerder heeft vermeld, zullen we een bijgewerkte testnetversie lanceren voordat we het product lanceren.</p>
<p>Wat onze gemeenschap betreft, hebben we met succes opgebouwd tot meer dan 50K gemeenschapsgroep Flurry Finance (Officieel) bij <a href="https://t.me/FlurryFinance_Official" rel="nofollow noopener noreferrer" target="_blank">https://t.me/FlurryFinance_Official</a> Wat we hebben verwacht, maar ons nogal hulpeloos voelen, is het deel waar we zien dat oplichters onze identiteit gebruiken om naar geld te zoeken, waarbij we zelf ook patrouilleren en gemeenschappen waarschuwen voor dit frustrerende nieuws over “nieuwe valse groepen” of “nieuwe valse identiteit”, elke dag.</p>
<p>We hopen de goederen naar de gemeenschap te brengen, en dat herinnert me eraan, onze community-beheerder zal je op geen enkele manier een privébericht sturen, dus wees alsjeblieft op je hoede! Alle belangrijke data zijn ook gepubliceerd in onze medium IDO-sessie, dus bekijk daar de details: <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>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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>