R2F0ZS5pbyBBTUEgY29uIEJyaWdodFBvb2wgRmluYW5jZSAtIEZhaSB0cmFkaW5nIGluIG1vZG8gcGnDuSBpbnRlbGxpZ2VudGUgY29uIGxlIHJpY29tcGVuc2UgZGkgQUk=

2024-04-01, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/1711942525PHp3fKjg.png" alt=""><br><strong>Ora: 29 marzo 2024, ore 09:30 UTC</strong><br><strong>Gate.io ha ospitato una sessione di AMA (Ask-Me-Anything) con Lucas Kobus, Pool Master di BrightPool Finance nella Community di Gate.io Exchange.</strong><br><strong>Sito Web ufficiale: <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>Segui BrightPool Finance su <a href="https://t.me/brightpoolfinance" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/BrightpoolX" rel="nofollow noopener noreferrer" target="_blank">Cinguettare</a></strong></p>
<h2 id="h2-Q120Puoi20presentarti20ai20membri20della20comunit488047"><a name="Q1: Puoi presentarti ai membri della comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti ai membri della comunità?</h2><p>Lucas: Certo. Sono un Pool Master presso Brightpool Finance. Alcune parole su di me. Sono nel settore dal 2018. Ho scoperto la tecnologia blockchain mentre lavoravo presso l’Instituto Chartered di Management Accountants. Ero responsabile della promozione della blockchain presso i CFO delle grandi aziende globali. In seguito, sono stato responsabile dello sviluppo aziendale presso un’azienda di mining di BTC. Nel nostro momento migliore, avevamo una potenza di mining di 10EX. Nel 2021 ho incontrato Tom Piwonski. Mi ha spiegato la visione di Brightpool e mi ha affascinato totalmente.<br>In BP sono responsabile dello sviluppo aziendale e dei modelli di business.</p>
<h2 id="h2-Q220Per20favore20raccontaci20un20po20di20pi20sulla20tua20piattaforma20e20sul20suo20punto20di20vendita20unico556313"><a name="Q2: Per favore, raccontaci un po’ di più sulla tua piattaforma e sul suo punto di vendita unico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Per favore, raccontaci un po’ di più sulla tua piattaforma e sul suo punto di vendita unico?</h2><p>Lucas: Brightpool Finance (BP) è una piattaforma di trading decentralizzata che paga gli utenti per l’inserimento degli ordini. Abbiamo realizzato ordini limite con rendimento e integrato l’intelligenza artificiale per calcolare le ricompense degli ordini con l’uso del modello Black-Scholes.</p>
<p>Ciò che è davvero fantastico è che hai una commissione del 0% per gli ordini a limite e in futuro, swap senza fornitori di liquidità e la tariffa più bassa (&lt;0,1%).</p>
<p>Offriamo ai trader nuove possibilità e portiamo la loro esperienza di trading a un nuovo livello.</p>
<h2 id="h2-Q320Qual2020un20elemento20differenziante20del20vostro20prodotto20rispetto20agli20altri20concorrenti20in20Web3723938"><a name="Q3: Qual è un elemento differenziante del vostro prodotto rispetto agli altri concorrenti in Web3?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Qual è un elemento differenziante del vostro prodotto rispetto agli altri concorrenti in Web3?</h2><p>Lucas: Su Brightpool puoi effettuare ordini che sono quasi come ordini a limite - l’unica differenza è che blocchi i tuoi token per un certo periodo, come 1 ora, 1 giorno, 1 settimana - tu scegli e dopo averlo bloccato ricevi BRIX token come ricompensa per aver effettuato un ordine.</p>
<p>Permettimi di darti un esempio. ETH si negozia su Gate.io a 3524 USD, vuoi vendere 1 ETH a 3600 USD e desideri che il tuo ordine venga liquidato domani (intervallo di tempo di 1 giorno). Poni quell’ordine e immediatamente dopo aver bloccato 1 ETH su Brightpool, ricevi un pagamento in token BRIX che potrebbero valere circa 20-30 USD. Si tratta di un pagamento anticipato, quindi attendi un giorno. E il giorno successivo ci sono due scenari:</p>
<ol>
<li>Il prezzo di ETH è inferiore a 3600 USD - in tal caso ricevi il tuo 1 ETH e basta</li><li>Il prezzo di ETH è superiore a 3600 USD. Ad esempio, 3630 USD<br>In tal caso il tuo ordine viene liquidato e ricevi ciò che hai richiesto - 3600 USD.<br>Questa differenza di 30 USD è il ricavo di Brightpool (che poi verrà utilizzato per riacquisti).<br>Quindi hai venduto 1 ETH al tuo prezzo e hai ricevuto anche i token BRIX.</li></ol>
<p>Hai ottenuto il doppio del profitto!</p>
<p>Inoltre, Brightpool non ha bisogno di fornitori di liquidità. Utilizziamo liquidità esterna da altri DEX, e il token ha il supporto del ricavo e del buyback - torneremo su questo più tardi.</p>
<h2 id="h2-Q420Per20favore20ci20parli20un20po20del20tuo20token20La20sua20utilit20la20tokenomica20e20perch20dovremmo20tenerlo924558"><a name="Q4: Per favore, ci parli un po’ del tuo token. La sua utilità, la tokenomica e perché dovremmo tenerlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Per favore, ci parli un po’ del tuo token. La sua utilità, la tokenomica e perché dovremmo tenerlo?</h2><p>Lucas: Permettetemi di partire dal fatto che BRI è stato elencato su Gate.io ieri e al momento viene scambiato a humble x4 rispetto al prezzo di quotazione, che secondo me sembra un buon punto di ingresso. Ma tornando alle sue utilità. Innanzitutto, BRI è un token di governance di Brightpool Finance - questo è molto importante poiché ci sarà molto da governare. La comunità potrà decidere quali token dovrebbero essere elencati. Brightpool riacquisterà BRI dai ricavi della piattaforma, l’offerta totale di BRI è di 67M e faremo riacquisti e bruciamo l’ammontare totale di BRI fino a 1024. Quindi il token è DEFLAZIONARIO.</p>
<h2 id="h2-Q520Come20la20tua20piattaforma20e20il20tuo20token20portano20alla20generazione20di20entrate20per20te574661"><a name="Q5: Come la tua piattaforma e il tuo token portano alla generazione di entrate per te?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come la tua piattaforma e il tuo token portano alla generazione di entrate per te?</h2><p>Lucas: Il ricavo è generato dalla liquidazione degli ordini. Gli ordini vengono liquidati quando il prezzo di vendita è inferiore al prezzo corrente e quando il prezzo di acquisto è superiore al prezzo corrente.</p>
<p>In altre parole. Vendete l’1 ETH per 3600 USD e durante la liquidazione, il prezzo è di 3650 USD. La differenza di 50 USD è il reddito di Brightpool.</p>
<p>Acquisti 1 ETH a 3500 USD e durante la liquidazione il prezzo è 3450 USD. La differenza di 50 USD è il ricavo di Brightpool.</p>
<p>Si prega di ricordare che si riceve un premio aggiuntivo per effettuare l’ordine che vi compensa per la differenza di prezzo.</p>
<h2 id="h2-Q620Puoi20condividere20di20pi20sui20tuoi20piani20e20sulla20tua20roadmap78769"><a name="Q6: Puoi condividere di più sui tuoi piani e sulla tua roadmap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Puoi condividere di più sui tuoi piani e sulla tua roadmap?</h2><p>Lucas: C’è molto in corso. Lascia che lo elenchi punto per punto:</p>
<ol>
<li>Al momento, gli utenti possono ancora partecipare alla nostra competizione dimostrativa, prendere parte alla campagna Zealy e ottenere airdrop. Sarà attivo fino al lancio di Brightpool.</li><li>La prossima settimana avremo un’altra quotazione CEX. Quale? Sorpresa; rimanete sintonizzati</li><li>Il lancio di Brightpool avverrà ad aprile. Sarà massiccio. I primi trader riceveranno i premi più alti. Quindi restate sintonizzati.</li><li>Con il lancio delle competizioni di trading della piattaforma, avrete l’opportunità di ottenere premi fantastici.</li><li>Aggiorneremo nuove coppie di trading. Il prossimo token elencato sarà… Vi darò un piccolo indizio. Una delle monete più famose al mondo;</li><li>Partnership. Proprio ieri abbiamo annunciato partnership con PAAL AI e ne arriveranno presto di nuove.</li><li>Integrazioni della comunità. Nuove comunità di trading si uniranno a Brightpool molto presto.</li><li>Nuove pool e nuove catene - questo avverrà nel 2024.</li></ol>
<div class="blog-details-info"><br><div>Autore: <strong>comunità di Gate.io</strong>, Team 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, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>