R2F0ZS5pbyBBTUEgY29uIGlsIGNyZWF0b3JlIC0gdW4gZWNvc2lzdGVtYSBjb21wbGV0byBjb3N0cnVpdG8gc3UgYmxvY2tjaGFpbg==

<p><img src="https://gimg2.gateimg.com/image/article/16913993601.jpeg" alt=""><br><strong>Orario: 16 settembre 2021, 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 Tony Tran, CEO di Creator e Vivian, CMO di Creator e in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito web ufficiale: <a href="https://www.creatorchain.network/" rel="nofollow noopener noreferrer" target="_blank">https://www.creatorchain.network/</a></strong><br><strong>Twitter: <a href="https://twitter.com/CreatorCTR" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/CreatorCTR</a></strong><br><strong>Segui Creator su <a href="https://twitter.com/CreatorCTR" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/creatorplatform" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong></p>
<h2 id="h2-QampA20da20Gateio29704"><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-Q120Prima20di20procedere20potreste20per20favore20fornire20una20breve20autointroduzione20per20la20comunit599714"><a name="Q1: Prima di procedere, potreste per favore fornire una breve auto-introduzione per la comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Prima di procedere, potreste per favore fornire una breve auto-introduzione per la comunità?</h3><p><strong>Tony</strong>: Mi chiamo Tony Tran, CEO e co-fondatore di Creator. Ho iniziato la mia carriera e ho lavorato nell’industria IT per un periodo di 15 anni, di cui quasi 10 anni specializzati in Blockchain, IoT e AI.</p>
<p>Sono davvero un appassionato di informatica che continua sempre a imparare, sperimentare e aggiornarsi per stare al passo con le nuove tecnologie. Non perderei mai alcuna novità tecnologica. Quindi, nell’era dello sviluppo rivoluzionario della blockchain, mi sono preparato per molti nuovi progetti nel settore, iniziando con Creator come piattaforma BaaS, per rendere la blockchain più accessibile e potenziare l’economia.</p>
<p><strong>Vivian</strong> Buon pomeriggio ragazzi, sono Vivian, CMO di Creator.</p>
<p>Beh, dovreste sapere che Tony e io siamo colleghi e amici affini.</p>
<p>Ho sviluppato strategie di marketing di successo per molte imprese, in particolare nel settore IT.</p>
<p>Vedendo una enorme ondata di blockchain e criptovalute, così come le sue molteplici applicazioni, sono rimasto incuriosito e ho sentito il desiderio di tuffarmi ed esplorare le potenzialità di questo nuovo avanzamento tecnologico.</p>
<p>Riguardo al Progetto Creatore, il signor Tony condividerà in dettaglio.</p>
<h3 id="h3-Q220Cos20inizieremo20ora20a20conoscere20il20tuo20progetto20Di20cosa20si20tratta20il20tuo20progetto486801"><a name="Q2: Così inizieremo ora a conoscere il tuo progetto. Di cosa si tratta il tuo progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Così inizieremo ora a conoscere il tuo progetto. Di cosa si tratta il tuo progetto?</h3><p><strong>Tony</strong>: Grazie per aver posto questa domanda, mi piacerebbe presentare il nostro grande progetto a voi ragazzi!</p>
<p>Creator è una nuova piattaforma che si concentra sullo sviluppo di un sistema Blockchain-as-a-Service (BaaS). In essa, forniamo Smart Contract No Code, DApp Low Code e altri servizi Defi e NFT ai clienti.</p>
<p>La tecnologia blockchain semplificata da Creator aprirebbe la strada per tutti gli studi di giochi e sviluppatori per entrare nel mondo NFT gamificato.</p>
<p>Le funzionalità del creatore comprendono 4 servizi principali: Contratto intelligente senza codice, DAPP a basso codice, programma fedeltà e servizi Defi.</p>
<p>Creator ha un’interfaccia utente incredibilmente amichevole e molti servizi di background potenziati. Compilando alcune informazioni iniziali e facendo qualche clic, chiunque (con o senza competenze IT/Blockchain) può semplicemente avviare un Smart Contract o una DApp.<br><img src="https://gimg2.gateimg.com/image/article/16913996432.jpg" alt=""><br>La catena del creatore si basa su <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>/Substrato per una vera interoperabilità, governance della rete guidata dall’utente e personalizzazioni che si concentrano su DeFi, NFT e altri servizi blockchain.</p>
<p>Per maggiori dettagli, si prega di visitare il sito ufficiale.<br><a href="https://www.creatorchain.network/" rel="nofollow noopener noreferrer" target="_blank">https://www.creatorchain.network/</a></p>
<h3 id="h3-Q320Interessante20Da20quanto20tempo20stai20sviluppando20il20progetto102184"><a name="Q3: Interessante! Da quanto tempo stai sviluppando il progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Interessante! Da quanto tempo stai sviluppando il progetto?</h3><p><strong>Vivian</strong>: Certo.</p>
<p>Bene, l’idea del Creatore è stata coltivata per molto tempo, ma abbiamo ufficialmente creato il team e abbiamo iniziato a implementarla alla fine del 2020.</p>
<p>Fin dall’inizio, abbiamo stretto partnership e ricevuto investimenti da grandi nomi del settore, che hanno portato al successo del rialzo di 2 milioni di dollari nella fase di finanziamento.</p>
<p>Condividiamo tutti i dettagli qui, puoi dare un’occhiata a questo <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>:<br><a href="https://creatorplatfor1.medium.com/creator-raised-2m-funding-fd34a95a665" rel="nofollow noopener noreferrer" target="_blank">https://creatorplatfor1.medium.com/creator-raised-2m-funding-fd34a95a665</a></p>
<p>Dopo un lungo e faticoso viaggio, abbiamo finalmente avuto successo nell’IDO di CTR sul dual launchpad - Ignition PAID network e MoonStarter mercoledì 8 settembre 2021.</p>
<p>L’allocazione totale è di 4.000.000 CTR su entrambe le piattaforme. Il creatore è stato anche inserito in <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> lo stesso giorno.</p>
<p>Ora puoi facilmente andare e comprare il token su https:// <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>.org/ . E presto saremo elencati su Gate.io.</p>
<p>Significa che entro 24 ore potrete scambiare i token CTR su Gate.io.</p>
<p>Per favore, segui i nostri canali ufficiali per ulteriori informazioni.</p>
<h3 id="h3-Q420Il20prodotto2020gi20finito20o2020ancora20in20fase20di20produzione20Nel20caso20fosse20gi20completo20potreste20mostrarci20alcune20foto20o20video826369"><a name="Q4: Il prodotto è già finito o è ancora in fase di produzione? Nel caso fosse già completo, potreste mostrarci alcune foto o video?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Il prodotto è già finito o è ancora in fase di produzione? Nel caso fosse già completo, potreste mostrarci alcune foto o video?</h3><p><strong>Tony</strong>: La tabella di marcia di seguito illustra chiaramente il processo su cui sta lavorando il team di Creator. Tutti i compiti procedono come previsto:<br><img src="https://gimg2.gateimg.com/image/article/16913996633.jpg" alt=""><br>Attualmente abbiamo completato il nostro testnet e stiamo per rilasciare una nuova aggiunta alla nostra piattaforma, ovvero lo staking alla fine del Q4. Sarà una buona occasione per i titolari di Creator di ottenere più vantaggi dal possesso dei nostri token.<br><a href="https://block-explorer.testnet.creatorchain.network" rel="nofollow noopener noreferrer" target="_blank">https://block-explorer.testnet.creatorchain.network</a><br>Ecco una dimostrazione passo dopo passo su come creare ERC-20 in <a href="/how-to-buy/ontology-ont" rel="nofollow noopener noreferrer" target="_blank">dove comprare ONT</a> Gilda di rete:<br><a href="https://www.youtube.com/watch?v=-Y1w2SDFfno" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/watch?v=-Y1w2SDFfno</a></p>
<h3 id="h3-Q520Questo2020davvero20un20grande20traguardo20finora20Congratulazioni20Potresti20dirci20a20quale20tipo20di20investitori2020rivolto20il20tuo20progetto387347"><a name="Q5: Questo è davvero un grande traguardo finora! Congratulazioni! Potresti dirci a quale tipo di investitori è rivolto il tuo progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Questo è davvero un grande traguardo finora! Congratulazioni! Potresti dirci a quale tipo di investitori è rivolto il tuo progetto?</h3><p><strong>Vivian</strong>: Il creatore dà il benvenuto a tutti gli investitori per unirsi allo sviluppo e beneficiare del progetto.</p>
<p>Detto questo, gli investitori a lungo termine guadagnerebbero i maggiori benefici poiché miriamo a creare un ecosistema associato a Creator, dove i detentori di CTR possono sfruttare le varie utilità del token tramite il programma fedeltà, il mercato NFT e altri servizi Defi.</p>
<p>Abbiamo ufficialmente pubblicato il modello di business completo dell’ecosistema. Dovreste esaminare per ottenere maggiori dettagli su come il Creatore opererebbe e interagirebbe con altre piattaforme nella casa nel suo complesso.</p>
<p>Link: <a href="https://creatorplatfor1.medium.com/creator-chain-network-full-landscape-597589be636e" rel="nofollow noopener noreferrer" target="_blank">https://creatorplatfor1.medium.com/creator-chain-network-full-landscape-597589be636e</a></p>
<p>Per essere più chiari, gli investitori a lungo termine riceveranno enormi benefici, tra cui l’agricoltura, il posizionamento, lo scambio di prodotti NFT nel mercato CTR e persino il voto DAO, che è fondamentale per il successo di un progetto.</p>
<p>Inoltre, il token CTR ha un alto livello di liquidità; gli investitori a lungo termine possono utilizzare il token CTR per scambiare con altri progetti sviluppati nel nostro ecosistema.</p>
<p>Ci piacerebbe ricevere i vostri commenti per contribuire al nostro modello di business. Grazie!</p>
<h3 id="h3-Q620A20proposito20il20vostro20progetto2020stato20auditato20da20qualche20azienda27424"><a name="Q6: A proposito, il vostro progetto è stato auditato da qualche azienda?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: A proposito, il vostro progetto è stato auditato da qualche azienda?</h3><p><strong>Tony</strong>: Oh sì, abbiamo superato un’approfondita ispezione per scoprire problemi e vulnerabilità nel codice sorgente condotta dalla principale società di revisione CertiK, con risultati impressionanti. Il creatore e i contratti intelligenti sono dichiarati aver raggiunto la sicurezza assoluta.</p>
<p>Puoi vedere il rapporto di revisione qui:<br><a href="https://www.certik.org/projects/creatorchain" rel="nofollow noopener noreferrer" target="_blank">https://www.certik.org/projects/creatorchain</a></p>
<p>Siamo totalmente consapevoli delle preoccupazioni sulla sicurezza degli utenti e che la sicurezza è la questione più importante riguardante lo sviluppo di un sistema blockchain.</p>
<p>Pertanto, non appena il progetto viene implementato, abbiamo raccolto tutti i migliori esperti di blockchain del settore per formare il nostro team.</p>
<p>Detto questo, vogliamo che tutti i detentori e gli utenti di CTR abbiano la tranquillità mentale quando utilizzano i nostri prodotti e servizi.</p>
<p>Siamo completamente qualificati per mantenere un sistema funzionale e sempre pronti ad affrontare tutti i problemi che potrebbero sorgere.</p>
<h3 id="h3-Q720Potreste20dirci20i20prossimi20passi20del20progetto909972"><a name="Q7: Potreste dirci i prossimi passi del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Potreste dirci i prossimi passi del progetto?</h3><p><strong>Vivian</strong>: Assolutamente!</p>
<p>In fasi di sviluppo successive, ci concentreremo sulla manutenzione, contemporaneamente all’aggiornamento e all’ottimizzazione dei nostri prodotti principali che sono No Code Smart Contract, Low Code DApp e altri servizi DeFi.</p>
<p>Oltre al nostro forte team di esperti, diamo il benvenuto a tutti i talentuosi sviluppatori là fuori a partecipare e contribuire allo sviluppo di Creator.</p>
<p>Abbiamo intenzione di condurre una serie di concorsi e competizioni per attirare più talenti a unirsi alla nostra rete.<br>E come appena accennato, il Creator sta costruendo un ecosistema completo con molte caratteristiche e servizi unici che si aggiungono ai benefici dei detentori di CTR.</p>
<p>Inoltre, ci sforziamo anche di sviluppare le nostre forti comunità mantenendo l’interazione con i membri attraverso attività come AMA o Mini Giochi con numerosi premi distribuiti.</p>
<p>Seguiamo sempre e aggiorniamo il pubblico di CTR con notizie informative e immediate nel settore, in modo che possano trarre efficacemente le proprie conclusioni.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>