R2F0ZS5pbyBBTUEgY29uIEhpc3RvcnlEQU8tIFBlciBjcmVhcmUgdW5hIHN0b3JpYSBkaSBibG9jY28=

<p><img src="https://gimg2.gateimg.com/image/article/167531685111.jpeg" alt=""><br><strong>Ora: 12 ottobre 2022, 3: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 il Co-Fondatore di HistoryDAO, Sky Harris nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://historydao.io/" rel="nofollow noopener noreferrer" target="_blank">https://historydao.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/History_DAO" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/History_DAO</a></strong><br><strong>Discord: <a href="https://discord.gg/zUTG6sQxNx" rel="nofollow noopener noreferrer" target="_blank">https://discord.gg/zUTG6sQxNx</a></strong><br><strong>Segui HistoryDAO su <a href="https://t.me/historydao_official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/History_DAO" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/167531701922.png" alt=""><br><strong>Sky Harris — Co-Fondatore di HistoryDAO</strong><br>Dagli Stati Uniti. Laureato presso l’Università di Utah con una laurea in inglese e una specializzazione in storia. Gestione generale dell’azienda e del comitato di governance dei contenuti. Oltre 10 anni di esperienza nella produzione di contenuti e strategia di mercato. Ex dirigente di ByteDance con un’ampia rete industriale in tutta l’America del Nord.</p>
<h3 id="h3-QampA20da20Gateio442237"><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</h3><h3 id="h3-Q120Puoi20presentarti20e20parlare20di20HistoryDAO471748"><a name="Q1: Puoi presentarti e parlare di HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti e parlare di HistoryDAO?</h3><p><strong>Cielo</strong>: Ciao a tutti! Sono Sky Harris, co-fondatore di HistoryDAO. In precedenza ho lavorato su un protocollo di prestito, un DEX-builder, un sistema operativo <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e una soluzione di pagamento fiat-crypto. Vengo da un background di marketing tecnologico Web2 presso ByteDance e Lenovo e sono entusiasta di presentare HistoryDAO oggi.</p>
<p>HistoryDAO è dove il mondo registra la storia in Web3. Il mondo si unisce sulla piattaforma HistoryDAO per coniare eventi storici e attuali in modo immutabile sulla blockchain da conservare come HistoryNFT. La decentralizzazione e la democratizzazione della storia ora risiedono nelle nostre mani con la tecnologia blockchain e NFT, governate da noi, il DAO, il popolo.<br><img src="https://gimg2.gateimg.com/image/article/167531776533.png" alt=""><br>Scrivi, registra, analizza, giudica e conia il nostro mondo mentre si svela in tutto il globo ogni giorno con HistoryDAO e HistoryNFTs.</p>
<h3 id="h3-Q220Nella20domanda20precedente20hai20menzionato20che20HistoryDAO2020il20luogo20in20cui20il20mondo20Web320registra20la20storia20il20che20suona20molto20interessante20Puoi20approfondire20lintenzione20originale20e20il20concetto20di20HistoryDAO710876"><a name="Q2: Nella domanda precedente hai menzionato che HistoryDAO è il luogo in cui il mondo Web3 registra la storia, il che suona molto interessante. Puoi approfondire l’intenzione originale e il concetto di HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Nella domanda precedente hai menzionato che HistoryDAO è il luogo in cui il mondo Web3 registra la storia, il che suona molto interessante. Puoi approfondire l’intenzione originale e il concetto di HistoryDAO?</h3><p><strong>Cielo</strong>: Certo! Come storici, abbiamo innumerevoli esempi di storia scritta in modo ingiusto e non veritiero dai vincitori. Milioni di documenti, artefatti e preziose testimonianze della storia sono andati perduti nel corso dei millenni della nostra esistenza umana.</p>
<p>HistoryDAO restituisce il potere nelle mani delle persone per registrare veramente e in modo immutabile la storia. Abbiamo visto che le attuali tendenze commerciali nel giornalismo sono modelli di business click-bait che hanno lo scopo solo di attirare l’attenzione dei loro clienti e spesso sono infiammatori. Vogliamo cambiare il modo in cui la storia viene registrata in Web3.</p>
<h3 id="h3-Q320Qual2020attuale202020Stato2020e20il20piano20di20sviluppo20futuro20di20HistoryDAO958098"><a name="Q3: Qual è attuale   Stato  e il piano di sviluppo futuro di HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Qual è attuale <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">Stato</a> e il piano di sviluppo futuro di HistoryDAO?</h3><p><strong>Cielo</strong>: Visita oggi la piattaforma HistoryDAO su historydao.io per coniare i tuoi HistoryNFT. Puoi anche creare una serie di NFT per seguire gli eventi attuali più importanti mentre si svolgono e coniare momenti individuali per gli altri da acquistare e collezionare come HistoryNFT.</p>
<p>Finanzia la serie tramite un INO (Initial NFT Offering)!</p>
<p>Gli eventi attuali, lo sport, l’arte, la musica, la letteratura, l’esplorazione spaziale, la politica: queste sono tutte categorie che fanno eccellenti HistoryNFTs.</p>
<p>Abbiamo appena lanciato il token HAO, che gli utenti possono depositare per partecipare alla governance DAO, nonché al voto della comunità che garantisce la qualità degli HistoryNFTs e promuove i migliori NFT al centro della piattaforma.</p>
<p>Abbiamo lanciato su Gate.io ieri! Puoi trovare $HAO disponibile con coppie di scambio USDT/HAO oggi!</p>
<h3 id="h3-Q420C20qualche20differenza20tra20lOfferta20Iniziale20di20NFT20INO20ideata20da20HistoryDAO20e20lICO20e20lIEO876180"><a name="Q4: C’è qualche differenza tra l’Offerta Iniziale di NFT (INO) ideata da HistoryDAO e l’ICO e l’IEO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: C’è qualche differenza tra l’Offerta Iniziale di NFT (INO) ideata da HistoryDAO e l’ICO e l’IEO?</h3><p><strong>Cielo</strong>: Sono abbastanza diverse in quanto le ICO e le IEO si concentrano sulla vendita di token, mentre il nostro INO si concentra sulla vendita di NFT. Entrambe sono forme di crowdfunding/raccolta fondi, quindi funzionano in modo simile fondamentalmente.</p>
<p>Ma soprattutto, un INO può essere lanciato e partecipato da chiunque. Vogliamo davvero infondere queste idee di democratizzazione e decentralizzazione. E lo facciamo anche qui con gli INO.</p>
<h3 id="h3-Q520Rispetto20ad20altri20progetti20NFT20quali20sono20i20vantaggi20di20HistoryDAO996138"><a name="Q5: Rispetto ad altri progetti NFT, quali sono i vantaggi di HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Rispetto ad altri progetti NFT, quali sono i vantaggi di HistoryDAO?</h3><p><strong>Cielo</strong> Con HistoryDAO, gli utenti generano i contenuti. Il successo della piattaforma è il successo della sua comunità.</p>
<p>Decentralizzato, democratizzato, dalle persone e per le persone. La maggior parte degli NFT sono progetti lanciati da una piattaforma/azienda e commercializzati verso la sua base di utenti che acquista gli NFT per scopi di collezionismo, utilità, accesso anticipato, ecc.<br><img src="https://gimg2.gateimg.com/image/article/167531779744.png" alt=""><br>Ma con gli HistoryNFT, gli utenti creano il contenuto, determinano quali NFT dovrebbero avere successo in base al loro merito e alla loro qualità. Questo è abbastanza unico.</p>
<h3 id="h3-Q620Quali20sono20i20partner20attuali20di20HistoryDAO20Qual2020la20forma20di20cooperazione134054"><a name="Q6: Quali sono i partner attuali di HistoryDAO? Qual è la forma di cooperazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Quali sono i partner attuali di HistoryDAO? Qual è la forma di cooperazione?</h3><p><strong>Cielo</strong>: Abbiamo stretto una partnership con Metabit per aiutare a scalare il nostro progetto e far parte dello sviluppo delle blockchain attuali e future e di tutte le applicazioni che verranno costruite su di esse.</p>
<p>Ci siamo anche associati a VoiceStreet, un partner naturale per noi, poiché portano la musica su Web3 e il metaverso. Ci saranno molti momenti leggendari nella musica degni di essere coniati come NFT storici.</p>
<p>Near, Alchemy Pay, ForTube, PlayerOne, SomnLife, XCarnival, Heartrate, FitR, Drive2, LingoesGame, Port3, YeehaGame, Voice Street, Metabit, UneMeta, BetaMars, D1verse, Proud Kitty Gang, EyesFi, Jungo, CandyKitty, Quest3, Theia, Midgard Saga, Genki, and Twitterscan sono tutti progetti con cui abbiamo cooperato in termini di marchi e comunità.</p>
<h3 id="h3-Q720Come20partecipare20a20HistoryDAO20come20utente134323"><a name="Q7: Come partecipare a HistoryDAO come utente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Come partecipare a HistoryDAO come utente?</h3><p><strong>Cielo</strong>: In molti modi emozionanti! Su HistoryDAO, gli utenti possono coniare qualsiasi momento degli eventi attuali o della storia come un History NFT. Utilizza titoli, articoli, immagini e altro ancora per coniare questi momenti.</p>
<p>Puoi anche finanziare collettivamente la tua collezione NFT attraverso la nostra funzione INO, dove puoi creare una serie di NFT storici per tracciare eventi importanti e emetterli ad altri utenti.</p>
<p>Gli utenti saranno anche in grado di partecipare alle funzionalità DAO come la governance del progetto, il voto della comunità per promuovere e premiare gli eccellenti History NFT, il voto per rimuovere History NFT inaccurati e altro ancora.</p>
<p>Abbiamo anche lanciato un marketplace per comprare, vendere e scambiare HistoryNFTs!<br><img src="https://gimg2.gateimg.com/image/article/167531778055.png" alt=""><br>Oltre a ciò, unisciti sicuramente ai nostri social, contribuisci alla conversazione, condividi eventi e notizie interessanti e fai parte della nostra fantastica community.</p>
<h3 id="h3-Q820Gli20NFT20emessi20su20HistoryDAO20possono20essere20scambiati659647"><a name="Q8: Gli NFT emessi su HistoryDAO possono essere scambiati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Gli NFT emessi su HistoryDAO possono essere scambiati?</h3><p><strong>Cielo</strong>: Possono farlo! Possono essere scambiati su qualsiasi importante mercato di NFT di terze parti ETH/BNB, dato che permettiamo la creazione in entrambe ETH e <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> oggigiorno.</p>
<p>Il marketplace NFT di HistoryDAO offre le commissioni di transazione più basse e la maggior parte delle informazioni disponibili per il trading di NFT, quindi provatelo!</p>
<h3 id="h3-Q920Puoi20brevemente20presentare20il20modello20economico20di20HistoryDAO20HistoryDAO20emetter20in20seguito20un20token20Quali20saranno20le20caratteristiche20del20token403789"><a name="Q9: Puoi brevemente presentare il modello economico di HistoryDAO? HistoryDAO emetterà in seguito un token? Quali saranno le caratteristiche del token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q9: Puoi brevemente presentare il modello economico di HistoryDAO? HistoryDAO emetterà in seguito un token? Quali saranno le caratteristiche del token?</h3><p><strong>Cielo</strong>: Abbiamo appena lanciato il token $HAO che permetterà agli utenti di partecipare a tutte le fantastiche funzioni che la nostra DAO ha da offrire.</p>
<p>Attraverso la creazione di ottimi NFT storici, gli utenti saranno ricompensati con regolari eventi premio per promuovere i migliori NFT storici. Questi NFT saranno poi idonei per una serie di premi nel corso delle settimane, dei mesi e degli anni per garantire la loro qualità e ricompensare continuamente i grandi creatori sulla nostra piattaforma.</p>
<p>La serie di NFT sulla storia ha una varietà di funzionalità per premiare i creatori. Gli NFT individuali sulla storia in una serie di NFT sulla storia saranno elencati e acquistabili da altri utenti, con eventi più importanti in una serie di NFT sulla storia probabilmente ad accumulare più valore. Pensate alla stagione NBA, ad esempio, con giochi regolari, playoff e le finali che accumulano prezzi di mercato e valutazioni diverse.</p>
<h3 id="h3-Q1020Cosa20ne20pensi20dello20stato20attuale20dello20sviluppo20nel20mercato20NFT778005"><a name="Q10: Cosa ne pensi dello stato attuale dello sviluppo nel mercato NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q10: Cosa ne pensi dello stato attuale dello sviluppo nel mercato NFT?</h3><p><strong>Cielo</strong>: Crediamo che stiamo entrando in una nuova era di NFT. Generati dagli utenti, promossi dagli utenti, governati dagli utenti. Questa era dei NFT 2.0 vedrà una vasta gamma di NFT con diverse utilità che sono carichi di significato in modi diversi rispetto ai progetti NFT precedenti. E la registrazione della storia sarà una parte fondamentale di tutto questo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu</strong>. Gate.io Community<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, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>