R2F0ZS5pbyBBTUEgY29uIFppZ25hbHktVHV0dG8gaWwgUHJvZml0dG8sIE5lc3N1biBMYXZvcm8=

<p><img src="https://gimg2.gateimg.com/image/article/16848255231.jpg" alt=""><br><strong>Ora: 22 gennaio 2022, 13: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 Bartolome R Bordallo, Co-Fondatore &amp; CEO di Zignaly 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://zignaly.com/" rel="nofollow noopener noreferrer" target="_blank">https://zignaly.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/zignaly" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/zignaly</a></strong><br><strong>Segui Zignaly su <a href="https://t.me/ZignalyHQ" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://www.facebook.com/zignaly" rel="nofollow noopener noreferrer" target="_blank">Facebook</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16848257362.png" alt=""><br><strong>Bartolome R Bordallo — Co-Fondatore &amp; CEO di Zignaly</strong></p>
<h2 id="h2-QampA20da20Gateio418708"><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-Q120Puoi20darci20una20breve20introduzione20del20prodotto20e20del20team668183"><a name="Q1: Puoi darci una breve introduzione del prodotto e del team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi darci una breve introduzione del prodotto e del team?</h3><p><strong>Tole</strong> Sono Bartolome R. Bordallo, co-fondatore &amp; CEO di Zignaly. Sono un imprenditore seriale autodidatta e basato sui dati, con tutte le mie energie concentrate sulla rivoluzione del reddito passivo guidata da Zignaly.com.</p>
<p>Oltre a me stesso, abbiamo 2 co-fondatori a Zignaly.</p>
<p>David Rodriguez - un vecchio amico e un appassionato imprenditore, con il quale ho creato due aziende di successo. Si occupa di tutto il Marketing e i Dati presso Zignaly. In particolare, aiuta con i dati per prendere le decisioni chiave più razionali per il business.</p>
<p>Abdul Rafay Gadit, il nostro co-fondatore, è un ex banchiere con un track record di successo nella creazione e nella scalata massiccia di diverse attività operative in settori diversi. Da Zignaly, si occupa delle Finanze e dello Sviluppo Aziendale.</p>
<p>È importante menzionare il team altamente appassionato ed energico di oltre 30 persone di Zignaly, che opera in 11 paesi diversi. Da Zignaly, manteniamo la testa bassa e costruiamo.</p>
<p>Informazioni sul prodotto:<br>La piattaforma e il marketplace di Zignaly mettono in contatto i consumatori di tutti i giorni con i migliori investitori crypto comprovati del mondo in un sistema affidabile e facilitato che consente ai consumatori di beneficiare dell’esperienza, della leva finanziaria e delle dimensioni dei migliori trader e fondi che gestiscono le loro operazioni, in cambio di una parte dei profitti condivisi. Per i trader professionisti e i fondi, Zignaly permette un accesso senza precedenti a nuove fonti di finanziamento e follower, fungendo da capitale scalato per un potenziale di profitto notevolmente più elevato. Fino ad ora, oltre 300 trader professionisti stanno servendo oltre 400.000 utenti che hanno allocato oltre 125 milioni di dollari in asset crypto.</p>
<p>Zignaly sta attraversando ora la sua più grande trasformazione con ZignalyDAO (Zignaly diventa completamente decentralizzata) che riteniamo essere niente meno che una rivoluzione nell’investimento sociale - il nostro obiettivo è semplice: ‘Dare a chiunque e a tutti, ovunque nel mondo, pari accesso alle stesse capacità di investimento passive gestite da esperti che in passato erano disponibili solo all’1% più ricco.’</p>
<h3 id="h3-Q220Puoi20parlare20dei20obiettivi20del20progetto20e20di20cosa20hai20raggiunto20finora486641"><a name="Q2: Puoi parlare dei obiettivi del progetto e di cosa hai raggiunto finora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi parlare dei obiettivi del progetto e di cosa hai raggiunto finora?</h3><p><strong>Tolo</strong>: Quindi ho menzionato il nostro obiettivo per il futuro, ma ci sono molti obiettivi che abbiamo già raggiunto.</p>
<p>Zignaly ha sicuramente fatto molta strada, ma c’è ancora molto da fare. Ringraziamo i nostri 430.000 utenti di Zignaly che continuano a crescere e che ci hanno affidato come la loro soluzione di gestione degli investimenti in criptovalute tutto-in-uno.</p>
<p>Sostenuti dalla vostra fiducia nell’ecosistema di Zignaly e, soprattutto, dai vostri feedback, siamo arrivati fin qui. I nostri utenti hanno investito oltre 125 milioni di dollari con i nostri migliori trader esperti, che sono riusciti a generare rendimenti superiori al 700% solo quest’anno.</p>
<p>Oltre a ciò, abbiamo introdotto 22 diverse casseforti nell’ambito della cassaforte 2.0 di Zignaly, distribuendo oltre 1,2 milioni di dollari in ricompense per lo staking, questo si allinea perfettamente con la nostra ‘Rivoluzione del reddito passivo’. Abbiamo anche contribuito a finanziare 3 progetti IDO raccogliendo mezzo milione di dollari e un sovrasottoscrizione del 3000% su ZIGPad. Nel nostro percorso, siamo stati riconosciuti da Binance come uno dei loro migliori partner broker e da Bitmex come loro partner fidato per gli strumenti di trading insieme alla copertura dei principali media come Yahoo Finance, coindesk, Investing.com e altri. Ma siamo solo all’inizio qui.</p>
<p>Come la nostra evoluzione dalla piattaforma di segnali al mercato di condivisione dei profitti insieme a ZIGPad e alle casseforti, continuiamo a lavorare sulla nostra più grande trasformazione fino ad oggi - ZignalyDAO</p>
<p>È un approccio fresco e innovativo agli investimenti e al reddito passivo, che si estende ai territori del mondo DeFi.</p>
<p>L’idea è quella di dare potere agli investitori e trader per superare le barriere agli investimenti in criptovalute. La moneta ZIG avrà un ruolo fondamentale nell’ecosistema in evoluzione di Zignaly.</p>
<p>Per rispondere alla tua domanda, continueremo a costruire e ridefinire l’equità economica per tutti nel mondo e, per misurarla, abbiamo delineato obiettivi molto chiari per il ZignalyDAO: ‘$10 miliardi di TVL e più di 100 milioni di transazioni al mese, con un flusso di ricavi del 30%, entro il quarto trimestre del 2023’</p>
<p>Siamo pronti e impegnati a raggiungere i nostri obiettivi.</p>
<h3 id="h3-Q320C20stata20anche20unannuncio20ieri20da20parte20di20ZignalyDAO2020Siamo20curiosi20di20sapere20perch20DAO20Qual2020la20motivazione20dietro20di20essa59569"><a name="Q3: C’è stata anche un’annuncio ieri da parte di ZignalyDAO - Siamo curiosi di sapere perché DAO? Qual è la motivazione dietro di essa?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: C’è stata anche un’annuncio ieri da parte di ZignalyDAO - Siamo curiosi di sapere perché DAO? Qual è la motivazione dietro di essa?</h3><p><strong>Tole</strong>: Domanda interessante, Tom!</p>
<p>Perché DAO? Da Zignaly, non crediamo nei confini e un modello decentralizzato apre le porte a possibilità illimitate. Perché limitarsi solo al trading quando i gestori di fondi esperti possono aiutarti a ottenere i migliori rendimenti, fare una fortuna con gli NFT o ottenere profitti su quei sintetizzatori s&amp;p500?</p>
<p>Tutto ciò è possibile solo se adottiamo Defi, ed eccoci qui, compiamo il nostro primo passo verso la nostra visione di rimuovere i confini dal tuo portafoglio di investimenti. Come ho detto prima, il nostro modello basato su DAO non è solo un nuovo prodotto o un aggiornamento, è nient’altro che una rivoluzione del reddito passivo che rimuoverà le barriere agli investimenti in criptovalute.</p>
<p>Inoltre, abbiamo sempre preso sul serio il feedback della comunità, tanto che la maggior parte dei nostri prodotti vengono attentamente valutati e testati dai nostri utenti esperti prima di essere offerti alla comunità. In secondo luogo, la governance guidata dalla comunità è sempre stata al centro della nostra strategia fin dal lancio della moneta ZIG.</p>
<p>Con il DAO, stiamo veramente fornendo ai detentori di ZIG il potere decisionale e la vera proprietà che meritano.</p>
<p>Naturalmente, al centro di tutto ci sarà la moneta ZIG, rimanete sintonizzati sui nostri social per saperne di più sulla meccanica.</p>
<h3 id="h3-Q420In20cosa20si20differenzier20linvestimento20attraverso20ZignalyDAO20dallinvestimento20attraverso20uno20scambio20decentralizzato20o20centralizzato64178"><a name="Q4: In cosa si differenzierà l’investimento attraverso ZignalyDAO dall’investimento attraverso uno scambio decentralizzato o centralizzato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: In cosa si differenzierà l’investimento attraverso ZignalyDAO dall’investimento attraverso uno scambio decentralizzato o centralizzato?</h3><p><strong>Tole</strong>: Immaginiamo di essere la piattaforma con il grande pulsante verde “Investi”</p>
<p>Sinceramente, questo è tutto ciò che non è un exchange. A ZignalyDAO, vogliamo eliminare le complessità e trasformare gli investimenti in un’esperienza ‘seamless’.</p>
<p>Per cominciare, non si trovano trader professionisti sugli scambi (specialmente non su DEXs) con comprovati track record e un organizzato marketplace di condivisione dei profitti. Tuttavia, Zignaly si concentra sull’utilizzo dell’esperienza di questi trader professionisti in cambio di una parte dei profitti condivisi. Mentre c’è qualcuno che si occupa dei tuoi interessi finanziari a Zignaly, sei da solo sugli scambi, dove sopravvivono i più adatti e i deboli vengono liquidati. Nel frattempo, i più adatti guidano a Zignaly mentre coloro che non sono esperti di investimenti li seguono.</p>
<p>Una soluzione a finestra unica per tutte le tue esigenze di investimento - Mentre gli exchange si occupano delle esigenze degli utenti di scambiare/swap di token o di aggiungere liquidità alle pool, Zignaly va oltre tutto questo. Che si tratti di gestione del portafoglio tramite il nostro marketplace di profit-sharing, staking su Zignaly Vault, raffles di whitelist NFT o investimenti in IDO su ZIGPad, copriamo tutto, con il token ZIG che potenzia i nostri prodotti.</p>
<p>Registrati su più piattaforme diverse o su una sola; Zignaly.com - è la scelta degli utenti. Con la DAO, ci stiamo espandendo e stiamo pensando senza limiti in vista: aspettatevi più classi di attività, vie di investimento e molto altro ancora. L’ideologia rimane la stessa, ma la portata è estesa a più asset e non si limita solo al trading.</p>
<p>Sicurezza di alto livello - a differenza dei DEX in particolare, Zignaly è una piattaforma completamente sicura e protetta. Abbiamo molteplici livelli di sicurezza. È una piattaforma equa e trasparente che copre tutte le esigenze di investimento da cima a fondo.</p>
<p>Approccio basato sulla comunità - La nostra comunità è il nostro bene più prezioso. Zignaly non è solo una piattaforma, ma un gruppo di oltre 430.000 persone con una missione comune: ‘raggiungere una vera libertà finanziaria’. Con il nostro modello DAO, intendiamo veramente potenziare la nostra comunità e i detentori di ZIG, mettendo nelle loro mani importanti decisioni aziendali insieme a una vera proprietà dell’azienda. La sensazione di far parte di una comunità unita è senza paragoni e noi lo capiamo.</p>
<h3 id="h3-Q520Comprendiamo20il20ruolo20cruciale20che20i20trader20esperti20e20i20gestori20di20fondi20svolgeranno20su20ZignalyDAO2020come20fanno20i20potenziali20utenti20a20fidarsi20di20questi20esperti20Ci20sono20statistiche20o20fatti20che20supportano20le20loro20performance949580"><a name="Q5: Comprendiamo il ruolo cruciale che i trader esperti e i gestori di fondi svolgeranno su ZignalyDAO - come fanno i potenziali utenti a fidarsi di questi esperti? Ci sono statistiche o fatti che supportano le loro performance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Comprendiamo il ruolo cruciale che i trader esperti e i gestori di fondi svolgeranno su ZignalyDAO - come fanno i potenziali utenti a fidarsi di questi esperti? Ci sono statistiche o fatti che supportano le loro performance?</h3><p><strong>Tole</strong>: Questa è una domanda molto importante e sono contento che tu l’abbia fatta.</p>
<p>Non ricordo di aver risposto a questa domanda in altre interviste/AMAs.</p>
<p>Per rispondere a questa domanda, lasciatemi innanzitutto dire che in Zignaly la gestione del rischio va al di là dei “rendimenti” che un trader può generare.</p>
<p>Quando elenchi un nuovo trader/servizio, valutiamo le sue prestazioni da molteplici prospettive e la nostra priorità assoluta è quanto bene gestiscono il rischio. I nostri utenti ci affidano i loro fondi di investimento e va senza dire che la responsabilità di effettuare la migliore due diligence possibile sia su di noi. Ecco come valutiamo i nostri trader: <a href="https://medium.com/zignaly/risk-managers-not-gamblers-f0c14ef36c1f" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/zignaly/risk-managers-not-gamblers-f0c14ef36c1f</a></p>
<p>Come puoi vedere, le linee guida per l’elenco dei nostri servizi riguardano tutte la gestione del rischio. Per quanto riguarda la custodia degli asset, nella sua forma attuale, Zignaly è una piattaforma completamente non custodiale basata sul programma del broker di Binance. In parole più semplici, un account di scambio di Zignaly è tanto buono quanto un account di Binance, e i fondi che allocati ai trader non sono prelevabili da loro. Per quanto riguarda ZignalyDAO, condivideremo presto i nostri piani di sicurezza, quindi sii certo che la sicurezza degli asset degli utenti rimane la nostra massima priorità.</p>
<p>Secondo e soprattutto:<br>Nel nostro modello di profit-sharing, il trader non viene pagato a meno che non si esegua.</p>
<p>Ti fanno soldi, per fare soldi a se stessi, è così semplice.</p>
<p>Inoltre, ricordati che i nostri trader esperti sono tenuti a investire i propri fondi nel loro servizio, quindi sono coinvolti. Non dimenticare che stiamo lanciando Profit-sharing 2.0 per migliorare ulteriormente l’esperienza di investimento di Zignaly.<br><img src="https://gimg2.gateimg.com/image/article/16848257473.jpg" alt=""><br>Capisco che le mere parole senza dati a sostegno sono inutili, quindi ecco qui:<br>Ecco le performance del nostro miglior trader da giugno ‘21 a giugno ‘22<br>Dal ~300% al quasi ~800%, tutto mentre <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è sceso di circa il 40% dopo un picco del 100%, questo è un’ottima gestione del rischio da parte dei nostri trader.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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>