R2F0ZS5pbyBBTUEgbWV0IFJvb2JlZS1nZWJydWlrdCBBSSBlbiB2b2xsZWRpZyB0cmFuc3BhcmFudGUgc3RhdGlzdGlla2VuIG9tIG1lbnNlbiB0ZSBoZWxwZW4gaW50ZWxsaWdlbnRlIGludmVzdGVyaW5nZW4gdGUgZG9lbiBpbiBnZWRpZ2l0YWxpc2VlcmRlIGFjdGl2YQ==

<p><img src="https://gimg2.gateimg.com/image/article/17029728731.jpeg" alt=""><br><strong>Tijd: 14 december 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Nick, Community Manager van Roobee in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Uitwisseling Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://roobee.io/" rel="nofollow noopener noreferrer" target="_blank">https://roobee.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Roobee_invest" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Roobee_invest</a></strong><br><strong>Volg Roobee op <a href="https://t.me/roobee_invest" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/Roobee_invest" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17029730502.jpeg" alt=""><br><strong>Nick - Community Manager van Roobee</strong></p>
<h2 id="h2-QampA20van20Gateio906314"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kunt20u20mij20kort20iets20vertellen20over20het20Roobeeproject74528"><a name="Q1: Kunt u mij kort iets vertellen over het Roobee-project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u mij kort iets vertellen over het Roobee-project?</h3><p><strong>Nick</strong>: We hebben verschillende producten en richtingen waar we aan werken, waaronder een gecentraliseerd product RWA (app.roobee.io), een gedecentraliseerd product (roobee.finance) en Roobee DAO.</p>
<p>Op dit moment ligt onze focus op de gedecentraliseerde richting en het schalen van Roobee Finance. We bouwen Roobee Finance als een soort hub voor onze gebruikers, waarbij we alles op één plek bieden.</p>
<p>Gebruikers kunnen al portefeuillestatistieken bijhouden, uitwisselingen doen op EVM 14-netwerken en andere DeFi-functies gebruiken. We streven ernaar al onze producten op te schalen over netwerken die worden ondersteund door het gedecentraliseerde gedeelte. We hebben al verschillende interessante producten die gebruikers kunnen gebruiken in de meeste netwerken, zoals de marktplaatssectie waar gebruikers cryptocurrency in een paar klikken kunnen kopen. Bovendien hebben we de mogelijkheid toegevoegd voor gebruikers om te investeren in cryptocurrency met behulp van de DCA-strategie. Gebruikers hoeven slechts één keer hun cryptocurrency-aankoop in te stellen en een investeringsstrategie te kiezen; onze contracten zullen de rest regelen. Na verloop van tijd kunt u genieten van de resultaten.</p>
<p>We hebben ook nog een paar andere producten, namelijk Roobee DAO. Tokenhouders kunnen deelnemen aan de ontwikkeling van het project door middel van stemmen.<br><img src="https://gimg2.gateimg.com/image/article/17029730673.jpeg" alt=""><br>Naast DAO hebben we ook een gecentraliseerde oplossing waarmee gebruikers ETF’s op de traditionele markt (RWA) kunnen kopen en kunnen deelnemen aan Pre-IPO met behulp van cryptocurrency.</p>
<h3 id="h3-Q220Velen20hier20zijn20erg20nieuwsgierig20naar20hoe20ROOBEE20functioneert20als20een20utility20token20voor20het20netwerk20Welke20voordelen20brengt20het20zowel20voor20het20fonds20als20voor20de20eigenaren20met20zich20mee20Is20er20een20mechanisme20voor20beloningen20voor20het20vasthouden20en20wat20zijn20de20langetermijnvoordelen20voor20ROOBEEhouders704609"><a name="Q2: Velen hier zijn erg nieuwsgierig naar hoe ROOBEE functioneert als een utility token voor het netwerk. Welke voordelen brengt het zowel voor het fonds als voor de eigenaren met zich mee? Is er een mechanisme voor beloningen voor het vasthouden, en wat zijn de langetermijnvoordelen voor ROOBEE-houders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Velen hier zijn erg nieuwsgierig naar hoe ROOBEE functioneert als een utility token voor het netwerk. Welke voordelen brengt het zowel voor het fonds als voor de eigenaren met zich mee? Is er een mechanisme voor beloningen voor het vasthouden, en wat zijn de langetermijnvoordelen voor ROOBEE-houders?</h3><p><strong>Nick</strong>: Bedankt voor uw vraag! Wat betreft het gebruik van de token, is deze momenteel betrokken bij verschillende gebieden:<br>Op het gecentraliseerde product: gebruikers kunnen toegang krijgen tot Pre-IPO-producten zonder in de rij te hoeven wachten. Bovendien wordt de token gebruikt om gebruikers korting te geven op commissie.</p>
<p>Met betrekking tot onze gedecentraliseerde producten:<br>Tokenhouders kunnen voorstellen doen en stemmen in Roobee DAO. Via stemming nemen gebruikers beslissingen in de ontwikkeling van het project. Ook ontvangen ROOBEE-tokenhouders korting op vergoedingen voor het gebruik van onze platformproducten. Bijvoorbeeld, een gebruiker krijgt korting op de commissie bij het gebruik van de DCA-module.</p>
<p>Naast fee-kortingen zal de toepassing van de token worden geïmplementeerd in de WEB3-functies van het platform.<br><img src="https://gimg2.gateimg.com/image/article/17029730834.jpeg" alt=""><br>We overwegen ook om een kleine hoeveelheid ROOBEE te nemen voor het integreren van projecten. ROOBEE-tokens die op deze manier worden verkregen, worden rechtstreeks naar de DAO-schatkist gestuurd voor verdeling onder gebruikers die deelnemen aan de stemming over Roobee DAO.</p>
<h3 id="h3-Vraag20320Welk20echt20probleem20probeert20uw20project20op20te20lossen634326"><a name="Vraag 3: Welk echt probleem probeert uw project op te lossen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 3: Welk echt probleem probeert uw project op te lossen?</h3><p><strong>Nick</strong> We geloven dat er momenteel een hoge drempel is om te investeren in traditionele marktproducten, inclusief IPO’s, evenals het gebruik van DeFi.</p>
<p>We streven ernaar om elke gebruiker de mogelijkheid te bieden om met slechts een paar klikken en een minimale instapdrempel te beginnen met investeren.</p>
<p>Of het nu gaat om ETF’s voor bedrijven die actief zijn in de marihuana-industrie (een traditioneel marktproduct RWA) of de eerste aankoop van cryptocurrencies (BTC, ETH, enz.), we streven ernaar om beleggen een eenvoudige stap in het leven van iedereen te maken.</p>
<h3 id="h3-Q420Vertel20ons20over20uw20plannen20voor20de20toekomst20Welke20releases20zijn20in20voorbereiding45696"><a name="Q4: Vertel ons over uw plannen voor de toekomst. Welke releases zijn in voorbereiding?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Vertel ons over uw plannen voor de toekomst. Welke releases zijn in voorbereiding?</h3><p><strong>Nick</strong>: Bedankt voor het vragen! Dat is een zeer belangrijke vraag.</p>
<p>We hebben onlangs een belangrijke update uitgebracht waar we al enkele maanden aan hebben gewerkt. Een volledig herontwerp, nieuwe functies en mogelijkheden zijn al beschikbaar. Bovendien hebben we ondersteuning toegevoegd voor populaire blockchains zoals zkSync era, Scroll, BASE en anderen aan het platform.</p>
<p>Bijna al onze kernproducten zijn al geïmplementeerd; nu ligt onze focus op het schalen ervan over verschillende netwerken. Zo zijn we van plan om het DCA-module toe te voegen aan netwerken zoals: zkSync, Scroll en Linea. Hoewel het DCA-module al operationeel is in veel netwerken, willen we dat gebruikers op verschillende blockchains de DCA-strategie volledig waarderen.</p>
<p>We hebben ook plannen om het dashboard bij te werken om meer informatie over pools en gebruikersitems weer te geven<br>We hebben ook grote plannen voor 2024 om onze RWA-infrastructuur te versterken. We zullen nieuwe partners inschakelen om de productlijn van het project uit te breiden.</p>
<p>Begin 2024 zullen we je er meer over vertellen!</p>
<h3 id="h3-Q520Samenwerkingen20zijn20cruciajson20voor20elk20project20Kunt20u20mij20meer20vertellen20over20de20partners20van20ROOBEE703550"><a name="Q5: Samenwerkingen zijn cruciajson voor elk project. Kunt u mij meer vertellen over de partners van ROOBEE?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Samenwerkingen zijn cruciajson voor elk project. Kunt u mij meer vertellen over de partners van ROOBEE?</h3><p><strong>Nick</strong>: Dit is een zeer belangrijke vraag. Ongetwijfeld zijn sterke partnerschappen een significant voordeel voor elk project. Roobee streeft ernaar om samenwerkingen aan te gaan met marktleiders om hoogwaardige diensten aan gebruikers te bieden.</p>
<p>Bijvoorbeeld, onder onze partners, opmerkelijke projecten omvatten O3 Labs, ApeSwap, Mercuryo, Changelly, <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a>, Eenhoorn, Bitkeep, <a href="/price/bitgert-brise" rel="nofollow noopener noreferrer" target="_blank">Bitgert</a>, en anderen. We waarderen elke samenwerking en streven ernaar om meer voordelen te bieden aan onze gemeenschappen.</p>
<h2 id="h2-Live20QampA20vanuit20de20community100068"><a name="Live Q&amp;A vanuit de community" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live Q&amp;A vanuit de community</h2><h3 id="h3-Q120BELANGRIJKE20VRAAG20op20welk20netwerk20kan20ik20uw20token20krijgen376092"><a name="Q1: BELANGRIJKE VRAAG, op welk netwerk kan ik uw token krijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: BELANGRIJKE VRAAG, op welk netwerk kan ik uw token krijgen?</h3><p>1) BSC-ketting<br>2) Tron<br>3) <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a><br>4) <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a><br>Of een ander netwerk, kun je ons dat vertellen?</p>
<p><strong>Nick</strong>: De ROOBEE-token bevindt zich op veel blockchains. Bijvoorbeeld, je kunt ROOBEE-tokens opslaan in Ethereum, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, Polygon, Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>. En we zullen de hoeveelheid uitbreiden.</p>
<p>We hebben een paar plannen met betrekking tot de release van de NFT Roobee. Wat ik zeker kan zeggen, is dat we niet van plan zijn om een grote collectie van NFT’s uit te brengen. Maar we zijn wel van plan om een paar soorten NFT’s uit te brengen die rechtstreeks ten goede zullen komen aan de gebruikers en het project. Misschien bieden deze NFT’s kortingen of voegen ze extra functies toe voor Roobee Finance-gebruikers.</p>
<p>We zijn ook van plan om NFT-ondersteuning toe te voegen aan het Roobee Dashboard. Zodat gebruikers NFT-tokens in hun portefeuille kunnen volgen door hun portemonnee te verbinden.</p>
<h3 id="h3-V220Vertel20ons20een20beetje20over20beveiliging20Heeft20u20een20audit20van20het20platform20uitgevoerd20Zijn20de20slimme20contracten20foutloos20Wat20zijn20de20testresultaten981683"><a name="V2: Vertel ons een beetje over beveiliging? Heeft u een audit van het platform uitgevoerd? Zijn de slimme contracten foutloos? Wat zijn de testresultaten???" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Vertel ons een beetje over beveiliging? Heeft u een audit van het platform uitgevoerd? Zijn de slimme contracten foutloos? Wat zijn de testresultaten???</h3><p><strong>Nick</strong>: Dank u voor uw vraag, we begrijpen hoe belangrijk veiligheid is in ons vakgebied. We voeren grondige interne audits uit voordat we een release publiceren. Maar we realiseren ons ook dat een audit door een onafhankelijke derde partij noodzakelijk is. Daarom hebben we ons tot grote accountantskantoren gewend om onze contracten te herzien. We verzekeren je dat je ervan hebt gehoord. Zodra de audit is afgerond, maken we dit bekend op onze social media kanalen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>