R2F0ZS5pbyBBTUEgbWV0IEJyaWdodFBvb2wgRmluYW5jZS0gSGFuZGVsIHNsaW1tZXIgbWV0IEFJIFJld2FyZHM=

<p><img src="https://gimg2.gateimg.com/image/article/1711942525PHp3fKjg.png" alt=""><br><strong>Tijd: 29 maart 2024, 09:30 uur UTC</strong><br><strong>Gate.io organiseerde een AMA (Ask-Me-Anything) sessie met Lucas Kobus, Pool Master van BrightPool Finance in de Gate.io Exchange Community.</strong><br><strong>Officiële website: <a href="https://brightpool.finance/" rel="nofollow noopener noreferrer" target="_blank">https://brightpool.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/BrightpoolX" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/BrightpoolX</a></strong><br><strong>Volg BrightPool Finance op <a href="https://t.me/brightpoolfinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/BrightpoolX" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-Q120Kunt20u20zichzelf20voorstellen20aan20de20leden20van20de20gemeenschap990166"><a name="Q1: Kunt u zichzelf voorstellen aan de leden van de gemeenschap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u zichzelf voorstellen aan de leden van de gemeenschap?</h2><p>Lucas: Natuurlijk. Ik ben een Pool Master bij Brightpool Finance. Een paar woorden over mezelf. Ik zit sinds 2018 in de ruimte. Ik kwam blockchain-technologie tegen tijdens mijn werk bij het Chartered Institute of Management Accountants. Ik was verantwoordelijk voor het promoten van blockchain bij CFO’s van mondiale bedrijven. Later was ik hoofd business development bij een BTC-miningbedrijf. Op ons hoogtepunt hadden we 10EX mining power. In 2021 ontmoette ik Tom Piwonski. Hij legde me de visie van Brightpool uit en ik was er helemaal weg van.<br>Bij BP ben ik verantwoordelijk voor business development en businessmodellen.</p>
<h2 id="h2-Q220Vertel20ons20alstublieft20iets20meer20over20uw20platform20en20zijn20unieke20verkoopargument367409"><a name="Q2: Vertel ons alstublieft iets meer over uw platform en zijn unieke verkoopargument?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Vertel ons alstublieft iets meer over uw platform en zijn unieke verkoopargument?</h2><p>Lucas: Brightpool Finance (BP) is een gedecentraliseerd handelsplatform dat gebruikers betaalt voor het plaatsen van orders. We hebben limietorders uitgevoerd met opbrengst en AI aan boord gebracht om beloningen voor orders te berekenen met behulp van het Black-Scholes-model.</p>
<p>Wat echt geweldig is, is dat je 0% kosten hebt voor limietorders en in de toekomst swaps zonder liquiditeitsverschaffers en de laagste vergoeding (&lt;0.1%).</p>
<p>We bieden handelaren nieuwe mogelijkheden en tillen hun ervaring met handelen naar een nieuw niveau.</p>
<h2 id="h2-Q320Wat20is20een20belangrijk20onderscheidend20kenmerk20van20uw20product20ten20opzichte20van20andere20concurrenten20in20Web3334892"><a name="Q3: Wat is een belangrijk onderscheidend kenmerk van uw product ten opzichte van andere concurrenten in Web3?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat is een belangrijk onderscheidend kenmerk van uw product ten opzichte van andere concurrenten in Web3?</h2><p>Lucas: Bij Brightpool kun je bestellingen plaatsen die bijna lijken op limietorders - het enige verschil is dat je je tokens voor een bepaalde tijd vergrendelt, zoals 1 uur, 1 dag, 1 week - je kiest zelf - en nadat je ze vergrendelt, krijg je als beloning voor het plaatsen van een bestelling betaald met BRIX-tokens.</p>
<p>Laat me je een voorbeeld geven. ETH wordt verhandeld op Gate.io voor 3524 USD, je wilt 1 ETH verkopen voor 3600 USD en je wilt dat je bestelling morgen wordt afgehandeld (tijdsbestek van 1 dag). Je plaatst die bestelling en direct nadat je 1 ETH hebt vergrendeld bij Brightpool, word je betaald met BRIX-tokens die ongeveer 20-30 USD waard kunnen zijn. Het is een vooruitbetaling, dan wacht je 1 dag. En de volgende dag zijn er twee scenario’s:</p>
<ol>
<li>ETH-prijs is lager dan 3600 USD - in dat g ontvang je je 1 ETH en dat is het</li><li>ETH-prijs is hoger dan 3600 USD. Bijvoorbeeld, 3630 USD<br>In dat g wordt je bestelling afgehandeld en ontvang je wat je hebt aangevraagd - 3600 USD.<br>Dat verschil van 30 USD is de omzet van Brightpool (die later zal worden gebruikt voor inkoopacties).<br>Dus je hebt 1 ETH verkocht tegen jouw prijs en je hebt ook BRIX-tokens ontvangen.</li></ol>
<p>Je hebt dubbele winst gemaakt!</p>
<p>Bovendien heeft Brightpool geen liquiditeitsverschaffers nodig. We gebruiken externe liquiditeit van andere DEXes, en de token wordt ondersteund door inkomsten en terugkoop - daar komen we later op terug.</p>
<h2 id="h2-Q420Vertel20ons20alstublieft20een20beetje20over20uw20token20Zijn20bruikbaarheid20tokenomics20en20waarom20zouden20we20het20moeten20vasthouden213259"><a name="Q4: Vertel ons alstublieft een beetje over uw token. Zijn bruikbaarheid, tokenomics en waarom zouden we het moeten vasthouden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Vertel ons alstublieft een beetje over uw token. Zijn bruikbaarheid, tokenomics en waarom zouden we het moeten vasthouden?</h2><p>Lucas: Laat me beginnen met het feit dat BRI gisteren op Gate.io werd genoteerd en op dit moment wordt verhandeld op een bescheiden x4 van de noteringsprijs, dat er naar mijn mening uitziet als een goed instapmoment. Maar, terugkomend op de functionaliteiten. Allereerst is BRI een governance-token van Brightpool Finance - dit is erg belangrijk omdat er veel te besturen zal zijn. De gemeenschap zal kunnen beslissen welke tokens moeten worden genoteerd. Brightpool zal BRI terugkopen van de platformopbrengsten, BRI totale aanbod is 67M en we gaan terugkopen en verbranden tot het totale bedrag van BRI op 1024 staat. Dus de token is DEFLATOIR.</p>
<h2 id="h2-Q520Hoe20leidt20uw20platform20en20token20tot20inkomstengeneratie20voor20u181132"><a name="Q5: Hoe leidt uw platform en token tot inkomstengeneratie voor u?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe leidt uw platform en token tot inkomstengeneratie voor u?</h2><p>Lucas: De omzet wordt gegenereerd uit orderafwikkeling. Orders worden afgewikkeld wanneer de verkoopprijs lager is dan de huidige spotprijs en wanneer de koopprijs hoger is dan de huidige spotprijs.</p>
<p>Met andere woorden. Je verkoopt de 1 ETH voor 3600 USD en tijdens de afwikkeling is de prijs 3650 USD. Het verschil van 50 USD is de omzet van Brightpool.</p>
<p>Je koopt 1 ETH voor 3500 USD en tijdens de afwikkeling is de prijs 3450 USD. Het verschil van 50 USD is de omzet van Brightpool.</p>
<p>Houd er rekening mee dat u een aanvullende beloning ontvangt voor het plaatsen van de bestelling die u compenseert voor het prijsverschil.</p>
<h2 id="h2-Q620Kunt20u20meer20delen20over20uw20plannen20en20roadmap22612"><a name="Q6: Kunt u meer delen over uw plannen en roadmap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Kunt u meer delen over uw plannen en roadmap?</h2><p>Lucas: Er gebeurt veel. Laat me het punt voor punt opnoemen:</p>
<ol>
<li>Op dit moment kunnen gebruikers nog steeds meedoen aan onze demowedstrijd, deelnemen aan de Zealy-campagne en airdrops krijgen. Het blijft live tot Brightpool wordt gelanceerd.</li><li>Volgende week hebben we nog een CEX-notering. Welke? Verrassing; blijf op de hoogte</li><li>De lancering van Brightpool zal plaatsvinden in april. Het wordt groots. De eerste handelaren ontvangen de hoogste beloningen. Dus blijf op de hoogte.</li><li>Met de lancering van het platform zullen handelswedstrijden beginnen, dus je hebt de kans om fantastische beloningen te krijgen.</li><li>We zullen nieuwe handelsparen vermelden. Het volgende genoteerde token zal zijn… Ik geef je een kleine hint. Een van de bekendste munten ter wereld;</li><li>Samenwerkingen. Gisteren hebben we aangekondigd dat we partnerschappen zijn aangegaan met PAAL AI en er komen binnenkort nieuwe partnerschappen.</li><li>Community-integraties. Nieuwe handelsgemeenschappen zullen binnenkort aansluiten bij Brightpool.</li><li>Nieuwe pools en nieuwe chains - dat gebeurt in 2024.</li></ol>
<div class="blog-details-info"><br><div>Auteur: <strong>Gate.io community.</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>